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. スクリーンショット 2020-04-28 10.52.24.png スクリーンショット 2020-04-28 10.52.38.png

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. スクリーンショット 2020-04-28 11.18.37.png スクリーンショット 2020-04-28 11.16.02.png

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

スクリーンショット 2020-04-28 10.03.36.png 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,

スクリーンショット 2020-04-28 11.14.38.png

Recommended Posts

Deep learning / Deep learning from scratch 2 Chapitre 4 Mémo
Deep learning / Deep learning made from scratch Chapitre 3 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 5 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 7 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 8 Mémo
Deep learning / Deep learning made from scratch Chapitre 5 Mémo
Deep learning / Deep learning made from scratch Chapitre 4 Mémo
Deep learning / Deep learning from scratch 2 Chapitre 3 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 6 Mémo
[Mémo d'apprentissage] Le Deep Learning fait de zéro [Chapitre 7]
Deep learning / Deep learning made from scratch Chapitre 6 Mémo
[Mémo d'apprentissage] Deep Learning fait de zéro [Chapitre 5]
[Mémo d'apprentissage] Le Deep Learning fait de zéro [Chapitre 6]
Deep learning / Deep learning made from scratch Chapitre 7 Mémo
[Mémo d'apprentissage] Deep Learning fait de zéro [~ Chapitre 4]
Deep Learning from scratch Chapter 2 Perceptron (lecture du mémo)
Apprentissage amélioré pour apprendre de zéro à profond
Mémo d'auto-apprentissage "Deep Learning from scratch" (partie 12) Deep learning
Apprentissage profond à partir de zéro
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 9) Classe MultiLayerNet
Deep Learning from scratch ① Chapitre 6 "Techniques liées à l'apprentissage"
[Mémo d'apprentissage] Apprentissage profond à partir de zéro ~ Mise en œuvre de l'abandon ~
Mémo d'auto-apprentissage «Deep Learning from scratch» (10) Classe MultiLayerNet
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 11) CNN
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 19) Augmentation des données
Mémo d'apprentissage Python pour l'apprentissage automatique par Chainer du chapitre 2
Deep Learning 2 from scratch 1.3 Traitement du langage naturel 1.3 Résumé
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 1
Un amateur a trébuché dans le Deep Learning ❷ fait à partir de zéro Note: Chapitre 5
Un amateur a trébuché dans le Deep Learning ❷ fait à partir de zéro Note: Chapitre 2
Apprentissage profond à partir de zéro (calcul des coûts)
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 3
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 7
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 5
Un amateur a trébuché dans le Deep Learning ❷ fait de zéro Note: Chapitre 1
Un amateur a trébuché dans le Deep Learning ❷ fait à partir de zéro Note: Chapitre 4
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 18) One! Miaou! Grad-CAM!
Un amateur a trébuché dans le Deep Learning à partir de zéro.
Mémo d'apprentissage profond créé à partir de zéro
L'apprentissage en profondeur
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 2
Mémo d'auto-apprentissage "Deep Learning from scratch" (n ° 15) Tutoriel pour débutants TensorFlow
Tutoriel d'apprentissage en profondeur de la construction d'environnement
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 14) Exécutez le programme du chapitre 4 sur Google Colaboratory
Mémo d'auto-apprentissage "Deep Learning from scratch" (partie 8) J'ai dessiné le graphique du chapitre 6 avec matplotlib
Mémo d'auto-apprentissage "Deep Learning from scratch" (n ° 13) Essayez d'utiliser Google Colaboratory
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 10-2) Valeur initiale du poids
Apprentissage profond à partir de zéro (propagation vers l'avant)
Apprentissage profond / Apprentissage profond à partir de zéro 2-Essayez de déplacer GRU
Alignement d'image: du SIFT au deep learning
"Deep Learning from scratch" avec Haskell (inachevé)
[Windows 10] Construction de l'environnement "Deep Learning from scratch"
Enregistrement d'apprentissage de la lecture "Deep Learning from scratch"
[Deep Learning from scratch] À propos de l'optimisation des hyper paramètres
Apprentissage profond à partir des bases mathématiques (pendant la fréquentation)
Note d'étude LPIC201
Mémo d'apprentissage Django