C'est un concept très différent du chapitre 2 Perceptron.
--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)
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.
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
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)
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]])
X = np.array([1,2])
W = np.array([1,3,5],[2,4,6])
Y = np.dot(X,W)
print(Y)
>>> [5,11,17]
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....]
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
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
Pour les problèmes de classification à 10 classes, définissez le nombre de couches de sortie sur 10.
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.
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.
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.
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