[PYTHON] Deep Learning / Deep Learning von Grund auf neu Kapitel 3 Memo

1. Zuallererst

Ich lese ein Meisterwerk, ** "Deep Learning from Zero" **. Diesmal ist ein Memo von Kapitel 3. Um den Code auszuführen, laden Sie den gesamten Code von Github herunter und verwenden Sie das Jupiter-Notizbuch in Kapitel 03.

Neuronales Netzwerk mit 2,3 Schichten

Betrachten Sie ein dreischichtiges neuronales Netzwerk. Unter der Annahme, dass die Anzahl der Neuronen die Eingangsschicht 2, die erste Schicht 3, die zweite Schicht 2 und die Ausgangsschicht 2 ist, kann die Vorwärtsausbreitung durch die folgende Matrixberechnung durchgeführt werden.

import numpy as np

def sigmoid(x):
    return 1/(1+np.exp(-x))

def identity_function(x):
    return x

def init_network():
    network={}
    network['W1']=np.array([[0.1, 0.3, 0.5],[0.2, 0.4, 0.6]])
    network['b1']=np.array([0.1, 0.2, 0.3])
    network['W2']=np.array([[0.1, 0.4],[0.2, 0.5],[0.3, 0.6]])
    network['b2']=np.array([0.1, 0.2])
    network['W3']=np.array([[0.1, 0.3],[0.2, 0.4]])
    network['b3']=np.array([0.1, 0.2])    
    return network

def forward(network, x):
    W1, W2, W3 = network['W1'], network['W2'], network['W3']
    b1, b2, b3 = network['b1'], network['b2'], network['b3']

    a1 = np.dot(x, W1)+b1
    z1 = sigmoid(a1)
    a2 = np.dot(z1, W2)+b2
    z2 = sigmoid(a2)
    a3 = np.dot(z2, W3)+b3
    y = identity_function(a3)    
    return y
        
network=init_network()
x = np.array([1.0, 0.5])
y = forward(network, x)
print(y)

#Ausgabe
[0.31682708 0.69627909]

3. Argumentation mit einem trainierten Modell

Der Text speichert die trainierten Parameter des Netzwerks, die die Zahlen 0-9 (MNIST) identifizieren, und wird verwendet, um Rückschlüsse zu ziehen.

Die Anzahl der Neuronen im Netzwerk beträgt 784 in der Eingangsschicht, 50 in der ersten Schicht, 100 in der zweiten Schicht und 10 in der Ausgangsschicht. Wie zuvor kann die Vorwärtsausbreitung durch die folgende Matrixoperation ausgedrückt werden.

import sys, os
sys.path.append(os.pardir)  #Einstellungen zum Importieren von Dateien in das übergeordnete Verzeichnis
import numpy as np
import pickle
from dataset.mnist import load_mnist
from common.functions import sigmoid, softmax

def get_data():
    (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=False)
    return x_test, t_test

def init_network():
    with open("sample_weight.pkl", 'rb') as f:
        network = pickle.load(f)
    return network

def predict(network, x):
    W1, W2, W3 = network['W1'], network['W2'], network['W3']
    b1, b2, b3 = network['b1'], network['b2'], network['b3']

    a1 = np.dot(x, W1) + b1
    z1 = sigmoid(a1)
    a2 = np.dot(z1, W2) + b2
    z2 = sigmoid(a2)
    a3 = np.dot(z2, W3) + b3
    y = softmax(a3)
    return y

x, t = get_data()
network = init_network()
accuracy_cnt = 0
pred = []  #Bereiten Sie eine Liste vor, um das Inferenzergebnis zu speichern
for i in range(len(x)):
    y = predict(network, x[i])
    p = np.argmax(y) #Holen Sie sich den Index des wahrscheinlichsten Elements
    pred.append(p)  #Inferenzergebnisse speichern
    if p == t[i]:
        accuracy_cnt += 1

print("Accuracy:" + str(float(accuracy_cnt) / len(x)))

#Ausgabe
Accuracy:0.9352

Da ich die Inferenzergebnisse später einzeln sehen möchte, habe ich eine Liste hinzugefügt, um die Inferenzergebnisse "pred = []" und die Inferenz "pred.append (p)" im Code zu speichern.

Schauen wir uns nun an, wie wir individuelle Vorhersagen treffen. Da die Variable x das Bild enthält und die Variable pred das Inferenzergebnis enthält,

import matplotlib.pyplot as plt

fig = plt.figure(figsize=(10, 12))
for i in range(50):
    ax = fig.add_subplot(10, 10, i+1, xticks=[], yticks=[])
    ax.imshow(x[i].reshape((28, 28)), cmap='gray')
    ax.set_xlabel('pred='+str(pred[i]))

Die Inferenzergebnisse der 50 Bilder vom Anfang der Bilddaten werden angezeigt. Ich habe nur mit den beiden Bildern im roten Rahmen einen Fehler gemacht, was sehr gut ist.

4. Stapelverarbeitung

Übrigens ist es effizient, 100 Blätter gleichzeitig zu stapeln, auch wenn Sie dies beim Ableiten nicht einzeln tun. In diesem Fall müssen Sie nur den Inferenzteil des vorherigen Codes ändern.

batch_size = 100 #Anzahl der Chargen
accuracy_cnt = 0
pred = np.array([])  #Feld zum Speichern von Inferenzergebnissen(numpy)Bereiten
for i in range(0, len(x), batch_size):
    x_batch = x[i:i+batch_size]
    y_batch = predict(network, x_batch)
    p = np.argmax(y_batch, axis=1)
    pred = np.append(pred, p) #Inferenzergebnisse speichern
    accuracy_cnt += np.sum(p == t[i:i+batch_size])

print("Accuracy:" + str(float(accuracy_cnt) / len(x)))
pred = pred.astype(int)  #Inferenzergebnisse von float in int konvertieren

Nach wie vor haben wir Code hinzugefügt, um die Inferenzergebnisse zu speichern. Dieses Mal wird das Inferenzergebnis für die Stapelverarbeitung im Numpy-Format zurückgegeben. Bereiten Sie also das Feld zum Speichern von "pred = np.array ([])" und zum Speichern von "pred = np.append (pred, p)" vor. , Wenn es so bleibt wie es ist, wird es als" 1.0 "angezeigt. Um es am Ende auf eine Ganzzahl zurückzusetzen, wird pred = pred.astype (int) `gesetzt.

Der Punkt hier ist nun "y_batch = Vorhersagen (Netzwerk, x_Batch)". Dies bedeutet, dass wir 100 Daten in den Netzwerkeingang einfügen, sodass wir 100 Ausgänge erhalten. Apropos Bild der Matrixoperation früher,