Chapitre 3 Réseau de neurones Ne découpez que les bons points de Deeplearning à partir de zéro

réseau neuronal

C'est un concept très différent du chapitre 2 Perceptron.

Glossaire

--Couche d'entrée --Couche de sortie --Couche intermédiaire (couche cachée)

De la couche d'entrée à la couche de sortie, nous les appellerons la 0ème couche, la 1ère couche et la 2ème couche dans l'ordre.

D'après l'examen du chapitre 2, il peut être exprimé par la formule suivante

y = h(b+w1x1+w2x2)

h(x) = 0 (x <= 0)
       1 (x > 0)
a = b+w1x1+w2x2
h(a) = 0 (x <= 0)
       1 (x > 0)

Fonction d'activation

Implémentation de la fonction Step

h(x) = 1 (x >= 0)
       0 (x < 0)

Lorsque vous essayez d'exprimer une fonction d'étape en tant qu'expression

Puisqu'il ne peut pas être utilisé comme step_function (np.array ([1.0, 2.0]))

import numpy as np
x = np.array([-1.0, 1.0, 2.0])
y = x > 0
y
array([False, True, True], dtype=bool)
y = y.astype(np.int)
y
array([0, 1, 1])

Résumer ce qui précède dans une fonction

def step_function(x):
    return np.array(x > 0, dtype= np.int)

Peut être représenté par.

Implémentation de la fonction sigmoïde

h(x) = 1 / 1 + exp(-x)

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

x = np.array([-1.0, 1.0, 2.0])
sigmoid(x)

> array([0.2689, 0.73.., 0.88..])

Perceptron n'a que 0,1 signaux, mais NN a des signaux continus. N'utilisez pas de fonctions linéaires pour la fonction d'activation. L'utilisation de l'algèbre linéaire rend inutile l'approfondissement des couches d'un réseau neuronal.

Puisqu'il devient un réseau sans couches cachées, il n'est pas possible de profiter du multicouche

Fonction ReLU

Bien que le sigmoïde soit courant, une fonction appelée ReLU (Rectified Linear Unit) est principalement utilisée. La fonction ReLU peut être exprimée comme une expression mathématique comme suit.

h(x) = x (x > 0)
       0 (x <= 0)

la mise en oeuvre

def relu(x):
    return np.maximum(0, x)

Calcul de tableaux multidimensionnels

Produit intérieur de la matrice

A = np.array([[1,2],[3,4]])
B = np.array([[5,6],[7,8]])
np.dot(A, B)

>> array([[19, 22],[43, 50]])

A = np.array([1,2,3],[4,5,6])
B = np.array([[1,2],[3,4],[5,6]])

np.dot(A,B)

>> array([[22,28],[49,64]])

Produit interne du réseau neuronal

X = np.array([1,2])
W = np.array([1,3,5],[2,4,6])

Y = np.dot(X,W)
print(Y)
>>> [5,11,17]

Implémentation d'un réseau neuronal à 3 couches

Une formule simple pour un réseau de neurones à trois couches

A = XW = B

W1.shape = (2, 3)
W2.shape = (3, 2)
W3.shape = (2, 2)

A1 = np.dot(X, W1) + B1
Z1 = sigmoid(A1)

A2 = np.dot(Z1, W2) + B2
Z2 = sigmoid(A2)

A3 = np.dot(Z2, W3) + B3

Résumé de la mise en œuvre

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) # [0.3168.., 0.69....]

Conception de la couche de sortie

Fonction égale et fonction softmax

La fonction d'égalité sort l'entrée telle quelle. La fonction softmax est exprimée par la formule suivante

yk = exp(ak) / nΣi=1 exp(ai)
a = np.array([0.3, 2.9, 4.0])
exp_a = np.exp(a)
sum_exp_a = np.sum(exp_a)
y = exp_a = sum_exp_a

Précautions pour la mise en œuvre des fonctions softmax

Vous devez faire attention au débordement.

def softmax(a):
    c = np.max(a)
    exp_a = np.exp(a-c) #Mesures de débordement
    sum_exp_a = np.sum(exp_a)
    y = exp_a / sum_exp_a

    return y

Nombre de neurones dans la couche de sortie

Pour les problèmes de classification à 10 classes, définissez le nombre de couches de sortie sur 10.

Reconnaissance des numéros manuscrits

Ensemble de données MNIST

Ensemble d'images de nombres manuscrits. L'un des ensembles de données les plus connus. Il se compose d'images numériques de 0 à 9.
60 000 images de formation et 10 000 images de test sont disponibles, et ces images sont utilisées pour l'apprentissage et l'inférence.
Une utilisation courante de l'ensemble de données MNIST consiste à s'entraîner avec des images d'entraînement et à mesurer dans quelle mesure le modèle entraîné peut classer les images de test.

la mise en oeuvre

import sys, os
sys.path.append(os.pardir)
from dataset.mnist import load_mnist

(x_train, t_train), (x_test, t_test) = \
    load_mnist(flatten=True, normalize=False)

print(x_train.shape) # (60000, 784)
print(t_train.shape) # (60000,)
print(x_test.shape) # (10000, 784)
print(t_test.shape) # (10000,)

Renvoie les données MNIST lues au format (image d'entraînement, étiquette d'apprentissage), (image de test, étiquette de test).

import sys, os
sys.path.append(os.pardir)
import numpy as np
from datase.mnist import load_mnist
from PIL import Image

def img_show(img):
    pil_img = IMage.fromarray(np.unit8(img))
    pil_img.show()

(x_train, t_train), (x_test, t_test) = \
    load_mnist(flatten = True, normalize = False)

img = x_train[0]
label = t_train[0]
print(label) # 5

print(img.shape) # (784)
img = img.reshape(28, 28)
print(img.shape) # (28, 28)

img_show(img) #5 images sont affichées

L'image lue comme flatten = True est stockée dans une dimension sous la forme d'un tableau Numpy. Lorsqu'il est affiché, il doit être remodelé à une taille de 28 x 28.

Traitement d'inférence de réseau neuronal

Puisqu'il est classé en 10 nombres, il y a 10 couches de sortie. On suppose également qu'il y a deux couches cachées, la première couche cachée a 50 neurones et la deuxième couche a 100 neurones. Les nombres 50 et 100 peuvent être définis sur n'importe quelle valeur. Tout d'abord, nous définissons trois fonctions.

  1. get_data()
  2. init_network()
  3. predict()
def get_date():
    (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_date()
network = init_network()

accuracy_cnt = 0
for i in range(len(x)):
    y = predict(network, x[i])
    p = np.armax(y) #Obtenez l'index de l'élément le plus établi
    if p == t[i]:
        accurancy_cnt += 1
print("accurancy:" + str(float(accuracy_cnt) / len(x)))

Chargez les paramètres de poids entraînés stockés dans sample_weight.pkl. Ce fichier contient les paramètres de pondération et de biais. pkl sera expliqué dans le chapitre suivant.

Recommended Posts

Chapitre 3 Réseau de neurones Ne découpez que les bons points de Deeplearning à partir de zéro
Chapitre 2 Implémentation de Perceptron Ne découpez que les bons points de Deeplearning à partir de zéro
Chapitre 1 Introduction à Python Découpez uniquement les bons points de Deeplearning à partir de zéro
Python vs Ruby "Deep Learning from scratch" Chapitre 3 Implémentation d'un réseau neuronal à 3 couches
[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 La théorie et la mise en œuvre de l'apprentissage profond appris avec Python Chapitre 3
Application de Deep Learning 2 à partir de zéro Filtre anti-spam
[Deep Learning from scratch] Valeur initiale du poids du réseau neuronal utilisant la fonction sigmoïde
[Deep Learning from scratch] Poids initial du réseau neuronal lors de l'utilisation de la fonction Relu
Mémo d'apprentissage profond créé à partir de zéro
Version Lua Apprentissage profond à partir de zéro Partie 6 [Traitement d'inférence de réseau neuronal]
Écrivez vos impressions sur l'édition du framework Deep Learning 3 créée à partir de zéro
Enregistrement d'apprentissage de la lecture "Deep Learning from scratch"
[Deep Learning from scratch] À propos des couches requises pour implémenter le traitement de rétropropagation dans un réseau neuronal
Python vs Ruby "Deep Learning from scratch" Chapitre 4 Implémentation de la fonction de perte
Deep Learning from scratch ① Chapitre 6 "Techniques liées à l'apprentissage"
GitHub du bon livre "Deep Learning from scratch"
Deep Learning from scratch Chapter 2 Perceptron (lecture du mémo)
[Mémo d'apprentissage] Apprentissage profond à partir de zéro ~ Mise en œuvre de l'abandon ~
Apprentissage profond à partir de zéro
[Deep Learning from scratch] J'ai implémenté la couche Affine
Othello ~ De la troisième ligne de "Implementation Deep Learning" (4) [Fin]
[Deep Learning] Exécuter la console de réseau neuronal SONY à partir de CUI
Python vs Ruby "Deep Learning from scratch" Chapitre 3 Graphique de la fonction step, fonction sigmoid, fonction ReLU
Python vs Ruby "Deep Learning from scratch" Chapitre 1 Graphique de la fonction sin et de la fonction cos
[Deep Learning from scratch] Implémentation de la méthode Momentum et de la méthode AdaGrad
Essayez de créer un réseau de neurones / d'apprentissage en profondeur avec scratch
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 1
[Apprentissage en profondeur] Découvrez comment utiliser chaque fonction du réseau neuronal convolutif [DW jour 3]
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
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
Un amateur a trébuché dans le Deep Learning à partir de zéro.
"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
[Deep Learning from scratch] Implémentez le traitement de rétropropagation dans le réseau neuronal par la méthode de propagation de retour d'erreur
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 2
Deep Learning from scratch 4.4.2 Gradient pour les réseaux de neurones La question sur la fonction numerical_gradient a été résolue.
[Deep Learning from scratch] Principales méthodes de mise à jour des paramètres pour les réseaux neuronaux
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 10-2) Valeur initiale du poids
Deep learning / Deep learning from scratch 2 Chapitre 4 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 5 Mémo
Apprentissage profond à partir de zéro (calcul des coûts)
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 7 Mémo
Touchez l'objet du réseau neuronal
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