[PYTHON] "Deep Learning from Grund" Memo zum Selbststudium (Nr. 14) Führen Sie das Programm in Kapitel 4 in Google Colaboratory aus

Während ich "Deep Learning from Grund" (gelesen von Yasuki Saito, veröffentlicht von O'Reilly Japan) lese, werde ich die Websites notieren, auf die ich mich bezog. Teil 13 ←

Ich habe Google Colaboratory verwendet, um das Programm im Buch auszuführen.

Ich mache es mit einer solchen Ordnerstruktur.

content/
└ Laufwerksname/
     └My Drive/
        └Colab Notebooks/
            └deep_learning/
                ├common/
                ｜  ├functions.py
                ｜  └two_layer_net.py
                ├dataset/
                ｜  ├mnist.py
                ｜  ├mnist.pkl
                ｜  └lena.png
                ├ch04 
                ｜  ├train_neuralnet.ipynb
                ｜  └test_neuralne.ipynb
                ｜ 

Ändern Sie den Importteil von two_layer_net.py in Kapitel 4 und legen Sie ihn im allgemeinen Ordner fest.

zwei in den gemeinsamen Ordner gelegt_layer_net.py

import sys, os
sys.path.append(os.pardir)  
from functions import *
from gradient import numerical_gradient
import numpy as np

class TwoLayerNet:

    def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):
        #Gewichtsinitialisierung
        self.params = {}
        self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)
        self.params['b1'] = np.zeros(hidden_size)
        self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size)
        self.params['b2'] = np.zeros(output_size)

    def predict(self, x):
        W1, W2 = self.params['W1'], self.params['W2']
        b1, b2 = self.params['b1'], self.params['b2']
    
        a1 = np.dot(x, W1) + b1
        z1 = sigmoid(a1)
        a2 = np.dot(z1, W2) + b2
        y = softmax(a2)
        
        return y
        
    # x:Eingabedaten, t:Lehrerdaten
    def loss(self, x, t):
        y = self.predict(x)
        
        return cross_entropy_error(y, t)
    
    def accuracy(self, x, t):
        y = self.predict(x)
        y = np.argmax(y, axis=1)
        t = np.argmax(t, axis=1)
        
        accuracy = np.sum(y == t) / float(x.shape[0])
        return accuracy
        
    # x:Eingabedaten, t:Lehrerdaten
    def numerical_gradient(self, x, t):
        loss_W = lambda W: self.loss(x, t)
        
        grads = {}
        grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
        grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
        grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
        grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
        
        return grads
        
    def gradient(self, x, t):
        W1, W2 = self.params['W1'], self.params['W2']
        b1, b2 = self.params['b1'], self.params['b2']
        grads = {}
        
        batch_num = x.shape[0]
        
        # forward
        a1 = np.dot(x, W1) + b1
        z1 = sigmoid(a1)
        a2 = np.dot(z1, W2) + b2
        y = softmax(a2)
        
        # backward
        dy = (y - t) / batch_num
        grads['W2'] = np.dot(z1.T, dy)
        grads['b2'] = np.sum(dy, axis=0)
        
        dz1 = np.dot(dy, W2.T)
        da1 = sigmoid_grad(a1) * dz1
        grads['W1'] = np.dot(x.T, da1)
        grads['b1'] = np.sum(da1, axis=0)

        return grads

Ich habe den Code von train_neuralnet.py in mehrere Teile aufgeteilt und sie im interaktiven Modus ausgeführt.

from google.colab import drive
drive.mount('/content/drive')

Mounted at /content/drive

import sys, os
sys.path

['', '/env/python', '/usr/lib/python36.zip', '/usr/lib/python3.6', '/usr/lib/python3.6/lib-dynload', '/usr/local/lib/python3.6/dist-packages', '/usr/lib/python3/dist-packages', '/usr/local/lib/python3.6/dist-packages/IPython/extensions', '/root/.ipython']

sys.path.append(os.pardir)  #Einstellungen zum Importieren von Dateien in das übergeordnete Verzeichnis
sys.path.append('/content/drive/My Drive/Colab Notebooks/deep_learning/common')
sys.path.append('/content/drive/My Drive/Colab Notebooks/deep_learning/dataset')

sys.path

['', '/env/python', '/usr/lib/python36.zip', '/usr/lib/python3.6', '/usr/lib/python3.6/lib-dynload', '/usr/local/lib/python3.6/dist-packages', '/usr/lib/python3/dist-packages', '/usr/local/lib/python3.6/dist-packages/IPython/extensions', '/root/.ipython', '..', '/content/drive/My Drive/Colab Notebooks/deep_learning/common', '/content/drive/My Drive/Colab Notebooks/deep_learning/dataset']

import numpy as np
import matplotlib.pyplot as plt
from mnist import load_mnist
from two_layer_net import TwoLayerNet

Wenn Sie vor dem Ausführen dieses Skripts ein anderes Skript ausführen und der Inhalt der Datei oder des Ordners unterschiedlich ist, erhalten Sie hier einen ModuleNotFoundError. In diesem Fall können Sie nicht fortfahren, selbst wenn das Skript in Ordnung ist. Laufzeit> Sitzungen verwalten> Beenden Sie eine laufende Sitzung und versuchen Sie, sie nach einer Weile erneut auszuführen, und es scheint zu funktionieren.

#Daten lesen
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True)

network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)

iters_num = 10000  #Stellen Sie die Anzahl der Wiederholungen entsprechend ein
train_size = x_train.shape[0]
batch_size = 100
learning_rate = 0.1

train_loss_list = []
train_acc_list = []
test_acc_list = []

iter_per_epoch = max(train_size / batch_size, 1)

for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]
    
    #Gradientenberechnung
    #grad = network.numerical_gradient(x_batch, t_batch)
    grad = network.gradient(x_batch, t_batch)
    
    #Parameteraktualisierung
    for key in ('W1', 'b1', 'W2', 'b2'):
        network.params[key] -= learning_rate * grad[key]
    
    loss = network.loss(x_batch, t_batch)
    train_loss_list.append(loss)
    
    if i % iter_per_epoch == 0:
        train_acc = network.accuracy(x_train, t_train)
        test_acc = network.accuracy(x_test, t_test)
        train_acc_list.append(train_acc)
        test_acc_list.append(test_acc)
        print("train acc, test acc | " + str(train_acc) + ", " + str(test_acc))

#Zeichnen eines Diagramms
markers = {'train': 'o', 'test': 's'}
x = np.arange(len(train_acc_list))
plt.plot(x, train_acc_list, label='train acc')
plt.plot(x, test_acc_list, label='test acc', linestyle='--')
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
plt.legend(loc='lower right')
plt.show()

Außerdem wird das Lernergebnis in der pkl-Datei gespeichert.

#Speichern Sie das Netzwerkobjekt mit pickle.
import pickle
save_file = '/content/drive/My Drive/Colab Notebooks/deep_learning/dataset/TwoLayerNet_weight.pkl'   
with open(save_file, 'wb') as f:
    pickle.dump(network, f, -1) 

Lassen Sie uns die Testdaten anhand des gespeicherten Ergebnisses beurteilen.

import sys, os
sys.path.append(os.pardir) 
sys.path.append('/content/drive/My Drive/Colab Notebooks/deep_learning/common')
sys.path.append('/content/drive/My Drive/Colab Notebooks/deep_learning/dataset')

import numpy as np
import matplotlib.pyplot as plt
from mnist import load_mnist
from two_layer_net import TwoLayerNet

#Daten lesen
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=False)

#network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)
import pickle
weight_file = '/content/drive/My Drive/Colab Notebooks/deep_learning/dataset/TwoLayerNet_weight.pkl'
with open(weight_file, 'rb') as f:
    network = pickle.load(f)

#Überprüfen Sie den Inhalt des Identifikationsergebnisses
import matplotlib.pyplot as plt

def showImg(x):
    example = x.reshape((28, 28))
    plt.figure()
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(example)
    plt.show()
    return

test_size = 10
test_mask = np.random.choice(10000, test_size)
x = x_test[test_mask]
t = t_test[test_mask]

for i in range(10):
    y = network.predict(x[i])
    p= np.argmax(y)
    print("Richtige Antwort" + str(t[i]))
    print("Beurteilung[ " + str(p) + " ]")
    count = 0
    for v in y:
        print("["+str(count)+"] {:.2%}".format(v))
        count += 1
    showImg(x[i])

Gelegentlich erhalte ich einen ModuleNotFoundError, aber ich habe bestätigt, dass das Buchprogramm funktioniert.

Ich habe auch train_convnet.py in Kapitel 7 verschoben

Die folgenden Anpassungen waren erforderlich, um train_convnet.py in Kapitel 7 im interaktiven Modus auszuführen:

Ändern Sie die Importanweisung von simple_convnet.py im Ordner ch07 und legen Sie sie im Ordner common fest.

simple_convnet.py

from common.layers import *
from common.gradient import numerical_gradient

#Ändern Sie die import-Anweisung wie folgt und setzen Sie sie auf common
from layers import *
from gradient import numerical_gradient

Ändern Sie die Importanweisung der folgenden Module auf die gleiche Weise layers.py trainer.py

Erstellen Sie ein neues Notebook, hängen Sie das Laufwerk ein und legen Sie den Pfad fest.

from google.colab import drive
drive.mount('/content/drive')

import sys, os
sys.path.append(os.pardir)  #Einstellungen zum Importieren von Dateien in das übergeordnete Verzeichnis
sys.path.append('/content/drive/My Drive/Colab Notebooks/deep_learning/common')
sys.path.append('/content/drive/My Drive/Colab Notebooks/deep_learning/dataset')

Führen Sie das Skript train_convnet.py der Reihe nach aus. Ändern Sie jedoch die import-Anweisung, bevor Sie sie ausführen.

from mnist import load_mnist
from simple_convnet import SimpleConvNet
from trainer import Trainer

Ich konnte es auf die gleiche Weise wie das Programm in Kapitel 4 ausführen.

Teil 13 ← Klicken Sie hier, um eine Liste der Memos usw. anzuzeigen. Unlesbares Glossar