Deep learning / Deep learning made from scratch Chapitre 3 Mémo

1.Tout d'abord

Je lis un chef-d'œuvre, ** "Deep Learning from Zero" **. Cette fois, c'est un mémo du chapitre 3. Pour exécuter le code, téléchargez le code entier depuis Github et utilisez jupyter notebook dans ch03.

2.3 réseau neuronal de couche

Prenons un réseau neuronal à trois couches. En supposant que le nombre de neurones est la couche d'entrée 2, la première couche 3, la deuxième couche 2 et la couche de sortie 2, la propagation vers l'avant peut être effectuée par le calcul matriciel suivant.

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)

#production
[0.31682708 0.69627909]

3. Inférence avec le modèle entraîné

Le texte stocke les paramètres formés du réseau qui identifient les nombres 0-9 (MNIST) et sera utilisé pour faire des inférences.

Le nombre de neurones dans le réseau est de 784 dans la couche d'entrée, 50 dans la première couche, 100 dans la deuxième couche et 10. Comme précédemment, la propagation directe peut être exprimée par l'opération matricielle suivante.

import sys, os
sys.path.append(os.pardir)  #Paramètres d'importation des fichiers dans le répertoire parent
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 = []  #Préparer une liste pour enregistrer le résultat de l'inférence
for i in range(len(x)):
    y = predict(network, x[i])
    p = np.argmax(y) #Obtenez l'index de l'élément le plus probable
    pred.append(p)  #Enregistrer les résultats de l'inférence
    if p == t[i]:
        accuracy_cnt += 1

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

#production
Accuracy:0.9352

Puisque je veux voir les résultats de l'inférence individuellement plus tard, j'ai ajouté une liste pour enregistrer les résultats de l'inférence pred = [] et enregistrer l'inférence pred.append (p) dans le code.

Voyons maintenant comment nous faisons des prédictions individuelles. Puisque la variable x contient l'image et la variable pred contient le résultat de l'inférence,

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]))

Les résultats d'inférence des 50 images à partir du début des données d'image sont affichés. Je me suis trompé uniquement avec les deux images affichées dans le cadre rouge, ce qui est assez excellent.

4. Traitement par lots

À propos, même si vous ne le faites pas une par une lors de la déduction, il est efficace de traiter par lots 100 feuilles à la fois. Dans ce cas, il vous suffit de modifier la partie inférence du code précédent.

batch_size = 100 #Nombre de lots
accuracy_cnt = 0
pred = np.array([])  #Boîte pour stocker les résultats d'inférence(numpy)Préparer
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) #Enregistrer les résultats de l'inférence
    accuracy_cnt += np.sum(p == t[i:i+batch_size])

print("Accuracy:" + str(float(accuracy_cnt) / len(x)))
pred = pred.astype(int)  #Convertir les résultats d'inférence de float en int

Comme précédemment, nous avons ajouté du code pour enregistrer les résultats de l'inférence. Cette fois, le résultat de l'inférence est renvoyé au format numpy pour le traitement par lots, alors préparez la boîte pour enregistrer pred = np.array ([]), save pred = np.append (pred, p) , S'il est laissé tel quel, il sera affiché comme" 1.0 ", donc pour le renvoyer à un entier à la fin,` pred = pred.astype (int) ʻest défini.

Maintenant, le point ici est y_batch = prédire (réseau, x_batch). Cela signifie que nous mettons 100 données dans l'entrée réseau, donc nous obtenons 100 sorties. En parlant de l'image de l'opération matricielle plus tôt,