J'ai essayé de mettre en œuvre un apprentissage en profondeur qui n'est pas profond avec uniquement NumPy

Afin de comprendre l'essence de l'apprentissage en profondeur, il est important de partir de zéro, mais MNIST est difficile à mettre en œuvre CNN et il faut du temps pour apprendre. Donc, cette fois, j'ai utilisé l'ensemble de données Iris pour implémenter très facilement un apprentissage en profondeur "non profond" à trois couches (une couche lorsque compté dans la couche intermédiaire), c'est-à-dire juste un réseau de neurones. C'est l'apprentissage par lots, pas par mini-lots, mais il inclut à la fois la descente de gradient et la rétropropagation d'erreur (mais pas de manière probabiliste). Concernant la théorie de l'apprentissage en profondeur, mon livre préféré [Deep Learning from scratch](https://www.amazon.co.jp/%E3%82%BC%E3%83%AD%E3%81%] 8B% E3% 82% 89% E4% BD% 9C% E3% 82% 8BApprentissage en profondeur-% E2% 80% 95Python% E3% 81% A7% E5% AD% A6% E3% 81% B6% E3% 83 % 87% E3% 82% A3% E3% 83% BC% E3% 83% 97% E3% 83% A9% E3% 83% BC% E3% 83% 8B% E3% 83% B3% E3% 82% B0 % E3% 81% AE% E7% 90% 86% E8% AB% 96% E3% 81% A8% E5% AE% 9F% E8% A3% 85-% E6% 96% 8E% E8% 97% A4- Veuillez lire% E5% BA% B7% E6% AF% 85 / dp / 4873117585). C'est le meilleur livre qui soit vraiment facile à comprendre.

Détails

Je ne suis pas doué pour dessiner des diagrammes sur un ordinateur, donc je suis désolé pour l'écriture manuscrite. Je voudrais la source principale. De plus, les données Iris sont triées aléatoirement parmi celles répertoriées dans Version anglaise de Wikipedia.

Code source

La source peut être trouvée sur github. Python3.

Seul le code python est également publié ici. Téléchargez les données Iris depuis github.

iris.py

# coding: utf-8

import numpy as np

#Hyper paramètres
TRAIN_DATA_SIZE = 50  #TRAIN sur 150 données_DATA_SIZE est utilisé comme données d'entraînement. Le reste est utilisé comme données sur les enseignants.
HIDDEN_LAYER_SIZE = 6  #Couche intermédiaire(Couche cachée)Taille(Cette fois, la couche intermédiaire est une couche, donc scalaire)
LEARNING_RATE = 0.1  #Taux d'apprentissage
ITERS_NUM = 1000  #Nombre de répétitions

#Lire les données
#Par défaut'#'Est conçu pour sauter la ligne
x = np.loadtxt('iris.tsv', delimiter='\t', usecols=(0, 1, 2, 3))
raw_t = np.loadtxt('iris.tsv', dtype=int, delimiter='\t', usecols=(4,))
onehot_t = np.zeros([150, 3])
for i in range(150):
    onehot_t[i][raw_t[i]] = 1

train_x = x[:TRAIN_DATA_SIZE]
train_t = onehot_t[:TRAIN_DATA_SIZE]
test_x = x[TRAIN_DATA_SIZE:]
test_t = onehot_t[TRAIN_DATA_SIZE:]

#Initialisation poids / biais
W1 = np.random.randn(4, HIDDEN_LAYER_SIZE) * np.sqrt(2 / 4)  #Valeur initiale de He(Utilisez ceci pour ReLU)
W2 = np.random.randn(HIDDEN_LAYER_SIZE, 3) * np.sqrt(2 / HIDDEN_LAYER_SIZE)
b1 = np.zeros(HIDDEN_LAYER_SIZE)  #La valeur initiale est zéro * Je ne connais pas la raison car je regarde le Deep Learning fait de zéro
b2 = np.zeros(3)

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

#Fonction Softmax * Je ne sais pas comment implémenter cette fonction car je n'ai vu que le net.
def softmax(x):
    e = np.exp(x - np.max(x))
    if e.ndim == 1:
        return e / np.sum(e, axis=0)
    elif e.ndim == 2:
        return e / np.array([np.sum(e, axis=1)]).T
    else:
        raise ValueError

#Erreur d'entropie croisée
def cross_entropy_error(y, t):
    if y.shape != t.shape:
        raise ValueError
    if y.ndim == 1:
        return - (t * np.log(y)).sum()
    elif y.ndim == 2:
        return - (t * np.log(y)).sum() / y.shape[0]
    else:
        raise ValueError

#Propagation vers l'avant
def forward(x):
    global W1, W2, b1, b2
    return softmax(np.dot(relu(np.dot(x, W1) + b1), W2) + b2)

#Résultats des données de test
test_y = forward(test_x)
print((test_y.argmax(axis=1) == test_t.argmax(axis=1)).sum(), '/', 150 - TRAIN_DATA_SIZE)

#Boucle d'apprentissage
for i in range(ITERS_NUM):
    #Propagation vers l'avant avec stockage de données
    y1 = np.dot(train_x, W1) + b1
    y2 = relu(y1)
    train_y = softmax(np.dot(y2, W2) + b2)

    #Calcul de la fonction de perte
    L = cross_entropy_error(train_y, train_t)

    if i % 100 == 0:
        print(L)

    #Calcul du gradient
    #Utilisez la formule obtenue à partir du graphique de calcul
    a1 = (train_y - train_t) / TRAIN_DATA_SIZE
    b2_gradient = a1.sum(axis=0)
    W2_gradient = np.dot(y2.T, a1)
    a2 = np.dot(a1, W2.T)
    a2[y1 <= 0.0] = 0
    b1_gradient = a2.sum(axis=0)
    W1_gradient = np.dot(train_x.T, a2)

    #Mise à jour des paramètres
    W1 = W1 - LEARNING_RATE * W1_gradient
    W2 = W2 - LEARNING_RATE * W2_gradient
    b1 = b1 - LEARNING_RATE * b1_gradient
    b2 = b2 - LEARNING_RATE * b2_gradient

#Affichage des résultats

#Valeur L des données d'entraînement finales
L = cross_entropy_error(forward(train_x), train_t)
print(L)

#Résultats des données de test
test_y = forward(test_x)
print((test_y.argmax(axis=1) == test_t.argmax(axis=1)).sum(), '/', 150 - TRAIN_DATA_SIZE)