Einführung

Als ich nach etwas suchte, das das Bild des Lernfortschritts des Deep Learning auf Jupyter in Echtzeit anzeigen kann, fand ich eine Bibliothek namens Bokeh, also habe ich es versucht. Ich versuchte es.

Inhalt des Studiums

Ich habe Chainer verwendet, um eine einzelne Schicht von Deconvolution 2D zu trainieren (wie ein einfacher Filter). Weitere Informationen zur Entfaltung finden Sie unter Hier vorgestellt. Im folgenden GIF lernen wir, den Punkt ⇒ sphärisches Muster zu ändern.

Mit Bokeh können Sie Bilder mit dem Mausrad vergrößern und verkleinern. Dies ist praktisch, um das Lernen zu überprüfen.

Quelle

Im vorherigen Chainer war es notwendig, numpy einmal in Variable zu konvertieren, aber jetzt in Version 1.17 scheint es, dass es automatisch in Variable konvertiert wird. Für die Anzeige von Bokeh auf Jupiter hierなど参考にしています。

import chainer.links as L
import chainer.functions as F
from chainer import Variable, optimizers
import numpy as np
import math
import time

#Erstellen Sie ein sphärisches Muster (Gauß)
def make_one_core():            
    max_xy=15    
    sig=5.0
    sig2=sig*sig
    c_xy=7
    core=np.zeros((max_xy, max_xy), dtype= np.float32)
    for px in range(0, max_xy):
        for py in range(0, max_xy):
            r2=(px-c_xy)*(px-c_xy)+(py-c_xy)*(py-c_xy)
            core[py][px]=math.exp(-r2/sig2)*1
    return core.reshape((1, 1, core.shape[0], core.shape[1]))

#Erstellen Sie einen Punkt und ein sphärisches Bild
def get_image(N=1, img_w=128, img_h=128):
    
    #Zufällig 0.Machen Sie einen 1% -Punkt
    img_p = np.random.randint(0, 10000, size = N*img_w*img_h)
    img_p[img_p < 9990]=0
    img_p[img_p >= 9990]=255

    img_p = img_p.reshape((N,1,img_h, img_w)).astype(np.float32)
    
    decon_core = L.Deconvolution2D(1, 1, 15, stride=1, pad=7)
    #Wenden Sie ein sphärisches Muster auf W an
    decon_core.W.data = make_one_core()
    
    #Von Punkt zu Kugel konvertieren
    img_core = decon_core(img_p)#OK ohne Konvertierung in Variable
    
    return img_p, img_core.data    


#Erstzeichnung
from bokeh.plotting import figure
from bokeh.io import push_notebook, show, output_notebook
from bokeh.layouts import gridplot

output_notebook()

palette_256 = ['#%02x%02x%02x' %(i,i,i) for i in range(256)] #Für Schwarzweißanzeige in 256 Schritten

img_p, img_core = get_image()#Holen Sie sich Punkt und sphärisches Bild

img_h = img_p.shape[2]
img_w = img_p.shape[3]

plt1 = figure(title = 'epoch = --', x_range=[0, img_w], y_range=[0, img_h])
rend1 = plt1.image(image=[img_p[0][0]],x=[0], y=[0], dw=[img_w], dh=[img_h], palette=palette_256)

plt2 = figure(title = 'loss  = 0', x_range=plt1.x_range, y_range=plt1.y_range)
rend2 = plt2.image(image=[img_core[0][0]],x=[0], y=[0], dw=[img_w], dh=[img_h], palette=palette_256)

plts = gridplot([[plt1,plt2]], plot_width=300, plot_height=300)
handle = show(plts, notebook_handle=True)

#Einstellungen des Modelloptimierers
model =  L.Deconvolution2D(1, 1, 15, stride=1, pad=7)#1 Schicht Entfaltung
optimizer = optimizers.SGD(lr=0.001)#Es divergiert, wenn es groß ist
optimizer.setup(model)
 
#Berechnung
for epoch in range(0,31):    
    
    #Berechnen und aktualisieren Sie den Verlust durch 1-Schicht-Entfaltung
    model.cleargrads()
    img_y = model(img_p)
    loss = F.mean_squared_error(img_y, img_core)
    loss.backward()
    optimizer.update()
    
    #Stellen Sie Bild- / Verlustdaten ein
    rend1.data_source.data['image'] = [img_p[0][0]]
    rend2.data_source.data['image'] = [img_y.data[0][0]]
    plt1.title.text='epoch = '+str(epoch)
    plt2.title.text='loss  = '+str(loss.data)
    push_notebook(handle = handle)#Anzeige aktualisieren
    time.sleep(0.5)

[PYTHON] Zeichnen Sie den Lernprozess von Deconvolution 2D auf jupyter (Bokeh)

Einführung

Inhalt des Studiums

Quelle