introduction

Quand je cherchais quelque chose qui pourrait afficher l'image de la progression d'apprentissage de l'apprentissage profond sur jupyter en temps réel, j'ai trouvé une bibliothèque appelée Bokeh, alors je l'ai essayé. Je l'ai essayé.

contenu de l'étude

J'ai utilisé Chainer pour entraîner une seule couche de Deconvolution 2D (comme un simple filtre). Pour plus d'informations sur Deconvolution, veuillez consulter Introduced here. Dans le gif ci-dessous, nous apprenons à changer le point ⇒ motif sphérique.

Bokeh vous permet de zoomer et dézoomer sur les images avec la molette de la souris, ce qui est pratique pour vérifier l'apprentissage.

La source

Dans le Chainer précédent, il était nécessaire de convertir numpy en Variable une fois, mais maintenant dans la version 1.17, il semble qu'il sera automatiquement converti en Variable. Pour l'affichage de Bokeh sur jupyter iciなど参考にしています。

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

#Créer un motif sphérique (Gauss)
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]))

#Créer une image ponctuelle et sphérique
def get_image(N=1, img_w=128, img_h=128):
    
    #Aléatoire 0.Faire un point de 1%
    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)
    #Appliquer un motif sphérique à W
    decon_core.W.data = make_one_core()
    
    #Convertir de point en sphère
    img_core = decon_core(img_p)#OK sans conversion en variable
    
    return img_p, img_core.data    


#Dessin initial
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)] #Pour un affichage noir et blanc en 256 étapes

img_p, img_core = get_image()#Obtenir un point et une image sphérique

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)

#Paramètres de l'optimiseur de modèle
model =  L.Deconvolution2D(1, 1, 15, stride=1, pad=7)#Déconvolution 1 couche
optimizer = optimizers.SGD(lr=0.001)#Il diverge quand il est grand
optimizer.setup(model)
 
#Calcul
for epoch in range(0,31):    
    
    #Calculer et mettre à jour les pertes grâce à la déconvolution à 1 couche
    model.cleargrads()
    img_y = model(img_p)
    loss = F.mean_squared_error(img_y, img_core)
    loss.backward()
    optimizer.update()
    
    #Définir les données d'image / de perte
    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)#Mettre à jour l'affichage
    time.sleep(0.5)

Dessinez le processus d'apprentissage de Deconvolution 2D sur Jupyter (Bokeh)

introduction

contenu de l'étude

La source