Implémentation d'un réseau neuronal à 3 couches (pas d'apprentissage)
introduction
Cet article est une continuation de Machine Learning ④ Neural Network Implementation (NumPy uniquement). Cet article concerne la mise en œuvre d'un réseau de neurones en utilisant uniquement NumPy. Certaines parties du lien ci-dessous ne chevauchent pas l'explication, veuillez donc les lire également. Apprentissage automatique ① Principes de base de Perceptron Machine learning ② Fonction d'activation de Perceptron Apprentissage automatique ③ Introduction et implémentation de la fonction d'activation Apprentissage automatique ④ Implémentation de réseau neuronal (NumPy uniquement)
référence
Références: O'REILLY JAPAN Deep Learning from scratch Articles jusqu'à présent: Apprentissage automatique ① Principes de base de Perceptron Machine learning ② Fonction d'activation de Perceptron Apprentissage automatique ③ Introduction et implémentation de la fonction d'activation Apprentissage automatique ④ Implémentation de réseau neuronal (NumPy uniquement)
Implémentation d'un réseau neuronal à 3 couches
Réseau de neurones à implémenter cette fois
Figure 5-1
La figure ci-dessus est le réseau neuronal construit dans cet article. Nous allons le diviser en chaque couche et le construire dans l'ordre.
la mise en oeuvre
Figure 5-2
Exprimons $ (1) a1 $ avec une formule. Il peut être dérivé de la somme du biais et du poids.
Équation 5-1
aa
(1)a1 = (1)w1,1\,\,x1 + (1)w1,2\,\,x2+b1
Comme la dernière fois, la "somme pondérée" de la première couche peut être calculée collectivement par la formule suivante.
aa
(1)A=X\,\,(1)W+(1)B
C'est,
Équation 5-2
A=
\begin{pmatrix}\,\,
(1)a1 & (1)a2 & (1)a3\,\,
\end{pmatrix}
X=
\begin{pmatrix}\,\,
x1 & x2\,\,
\end{pmatrix}
B=
\begin{pmatrix}\,\,
b1 & b2 & b3\,\,
\end{pmatrix}
W=
\begin{pmatrix}
\,\, (1)w1,1 & (1)w1,2 & (1)w1,3 \,\, \\
\,\, (1)w2,1 & (1)w2,2 & (1)w2,3 \,\,
\end{pmatrix}
Sur la base des informations ci-dessus, je voudrais exécuter l'expression ci-dessus à l'aide du tableau NumPy de Python. Pour le poids et le biais, les valeurs hypothécaires sont saisies.
5-1ThreeLayer_NeuralNetwork.py
import numpy as np
def sigmoid_function(x):
return 1 / (1 + np.exp(-x))
X = np.array([1.0, 0.5])
W1 = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])
B1 = np.array([0.1, 0.2, 0.3])
A1 = np.dot(X, W1) + B1
print(A1)
Résultat d'exécution
[0.3 0.7 1.1]
Pour l'explication du programme, veuillez consulter Machine Learning Learning Introduction / Implémentation de la fonction d'activation.
Ensuite, supposons que vous adoptiez la fonction sigmoïde comme fonction d'activation. Ensuite, on peut dire que cela devient comme suit.
Figure 5-3
5-2ThreeLayer_NeuralNetwork_activation_function.py
import numpy as np
def sigmoid_function(x):
return 1 / (1 + np.exp(-x))
X = np.array([1.0, 0.5])
W1 = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])
B1 = np.array([0.1, 0.2, 0.3])
A1 = np.dot(X, W1) + B1
#Adaptation de la fonction sigmoïde
Z1 = sigmoid_function(A1)
print(A1)
print(Z1)
Résultat d'exécution
[0.3 0.7 1.1]
[0.57444252 0.66818777 0.75026011]
Il peut être confirmé qu'il se situe dans la plage 0-1 comme décrit dans la précédente Apprentissage automatique ③ Introduction / implémentation de la fonction d'activation. Avec cet élan, nous allons implémenter de la 1ère à la 2ème couche.
5-3ThreeLayer_NeuralNetwork_cmp.py
import numpy as np
def sigmoid_function(x):
return 1 / (1 + np.exp(-x))
#Valeur d'entrée
X = np.array([1.0, 0.5])
#Poids de la première couche (la valeur numérique est appropriée)
W1 = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])
#Poids de la deuxième couche (la valeur numérique est appropriée)
W2 = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]])
#Biais de première couche
B1 = np.array([0.1, 0.2, 0.3])
#Biais de deuxième couche
B2 = np.array([0.1, 0.2])
A1 = np.dot(X, W1) + B1
#Adaptation de la fonction sigmoïde
Z1 = sigmoid_function(A1)
A2 = np.dot(Z1, W2) + B2
Z2 = sigmoid_function(A2)
print(A1)
print(Z1)
print(A2)
print(Z2)
Résultat d'exécution
[0.3 0.7 1.1]
[0.57444252 0.66818777 0.75026011]
[0.51615984 1.21402696]
[0.62624937 0.7710107 ]
Je l'ai rédigé rapidement, mais si vous avez des questions, veuillez commenter. ..
À propos de la fonction d'activation de la couche de sortie (nœud de sortie)
Il semble que la fonction d'activation de la couche de sortie (nœud de sortie) soit généralement divisée par le processus que vous souhaitez résoudre par apprentissage automatique. J'écris actuellement cet article en tant que critique, mais je me pencherai plus tard sur la conception de la couche de sortie. Maintenant, laissez-moi simplement écrire que le résultat de la couche de sortie peut être remplacé par le résultat que vous voulez réellement, et il est courant de sélectionner la fonction d'activation dans une direction différente de celle de la couche cachée en conséquence. ..
Pour faire la distinction entre la fonction d'activation de la couche cachée et la fonction d'activation de la couche de sortie, placez la fonction d'activation de la couche de sortie comme $ σ () $. (Dans la fonction d'activation du calque caché, mettez-le comme $ h () $.) De plus, cette fois, puisque le but est de distinguer explicitement $ σ () $ et $ h () $, une fonction égale (une fonction qui produit la valeur d'entrée telle qu'elle est) est adoptée pour $ σ () $. Le contenu ci-dessus est illustré.
Figure 5-3
Définissez et implémentez identity_function dans $ σ () $ cette fois.
5-4NeuralNetwork_identityf.py
import numpy as np
def sigmoid_function(x):
return 1 / (1 + np.exp(-x))
def identity_function(x):
return x
#Valeur d'entrée
X = np.array([1.0, 0.5])
#Poids de la première couche (la valeur numérique est appropriée)
W1 = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])
#Poids de la deuxième couche (la valeur numérique est appropriée)
W2 = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]])
#Poids de la troisième couche (la valeur numérique est appropriée)
W3 = np.array([[0.1, 0.3], [0.2, 0.4]])
#Biais de première couche
B1 = np.array([0.1, 0.2, 0.3])
#Biais de deuxième couche
B2 = np.array([0.1, 0.2])
#Biais de troisième couche
B3 = np.array([0.1, 0.2])
A1 = np.dot(X, W1) + B1
#Adaptation de la fonction Sigmad
Z1 = sigmoid_function(A1)
A2 = np.dot(Z1, W2) + B2
Z2 = sigmoid_function(A2)
A3 = np.dot(Z2, W3) + B3
Y = identity_function(A3)
print(A1)
print(Z1)
print(A2)
print(Z2)
print(A3)
print(Y)
Résultat d'exécution
[0.3 0.7 1.1]
[0.57444252 0.66818777 0.75026011]
[0.51615984 1.21402696]
[0.62624937 0.7710107 ]
[0.31682708 0.69627909]
[0.31682708 0.69627909]
Vous pouvez voir que la sortie fonctionne. Les deux dernières sorties ont la même valeur car elles utilisent une fonction d'égalité.
Organisez le programme de mise en œuvre de manière agréable
Puisqu'il s'agissait d'un programme supplémentaire, je le résumerai à la fin. (Il n'y a pas de changement dans le contenu du traitement.)
5-4NeuralNetwork_identityf.py
import numpy as np
def sigmoid_function(x):
return 1 / (1 + np.exp(-x))
def identity_function(x):
return x
def init_data():
data = {}
#Poids de la première couche (la valeur numérique est appropriée)
data['W1'] = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])
#Poids de la deuxième couche (la valeur numérique est appropriée)
data['W2'] = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]])
#Poids de la troisième couche (la valeur numérique est appropriée)
data['W3'] = np.array([[0.1, 0.3], [0.2, 0.4]])
#Biais de première couche
data['B1'] = np.array([0.1, 0.2, 0.3])
#Biais de deuxième couche
data['B2'] = np.array([0.1, 0.2])
#Biais de troisième couche
data['B3'] = np.array([0.1, 0.2])
return data
def run(data,x):
W1, W2, W3 = data['W1'], data['W2'], data['W3']
B1, B2, B3 = data['B1'], data['B2'], data['B3']
A1 = np.dot(X, W1) + B1
Z1 = sigmoid_function(A1)
A2 = np.dot(Z1, W2) + B2
Z2 = sigmoid_function(A2)
A3 = np.dot(Z2, W3) + B3
Y = identity_function(A3)
return Y
NN_data = init_data()
#Valeur d'entrée
X = np.array([1.0, 0.5])
Y = run(NN_data, X)
print(Y)
Résumé
Nous avons en fait construit un réseau neuronal à 3 couches. Je voudrais le développer pour un apprentissage futur basé sur cette méthode de construction.