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.
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]
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.
À 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,
Recommended Posts