[PYTHON] Ich habe versucht, Deep Learning zu implementieren, das nicht nur mit NumPy tiefgreifend ist

Um die Essenz des tiefen Lernens zu verstehen, ist es wichtig, von vorne zu beginnen, aber MNIST ist schwierig zu implementieren und es braucht Zeit, um zu lernen. Dieses Mal habe ich also den Iris-Datensatz verwendet, um ein dreischichtiges (nicht-tiefes "tiefes Lernen (eine Schicht, wenn in der mittleren Schicht gezählt) zu implementieren, dh nur ein neuronales Netzwerk, sehr einfach. Es handelt sich um Batch-Lernen, nicht um Mini-Batch, sondern um Gradientenabstieg und Fehler-Backpropagation (wenn auch nicht wahrscheinlich). In Bezug auf die Theorie des tiefen Lernens mein Lieblingsbuch [Deep Learning von Grund auf neu](https://www.amazon.co.jp/%E3%82%BC%E3%83%AD%E3%81%] 8B% E3% 82% 89% E4% BD% 9C% E3% 82% 8BTiefen-Lernen-% 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- Bitte lesen Sie% E5% BA% B7% E6% AF% 85 / dp / 4873117585). Es ist das beste Buch, das wirklich leicht zu verstehen ist.

Einzelheiten

Ich kann keine Diagramme auf einem Computer zeichnen, daher tut mir die Handschrift leid. Ich möchte die Hauptquelle. Außerdem werden Iris-Daten zufällig nach den in englische Version von Wikipedia aufgeführten Daten sortiert.

Quellcode

Die Quelle finden Sie unter github. Python3.

Hier wird auch nur der Python-Code veröffentlicht. Laden Sie Iris-Daten von [github] herunter (https://github.com/Matchlab314/Iris).

iris.py

# coding: utf-8

import numpy as np

#Hyperparameter
TRAIN_DATA_SIZE = 50  #TRAIN aus 150 Daten_DATA_GRÖSSE wird als Trainingsdaten verwendet. Der Rest wird als Lehrerdaten verwendet.
HIDDEN_LAYER_SIZE = 6  #Mittelschicht(Versteckte Ebene)Größe(Diesmal ist die mittlere Schicht eine Schicht, also skalar)
LEARNING_RATE = 0.1  #Lernrate
ITERS_NUM = 1000  #Anzahl der Wiederholungen

#Daten lesen
#Standardmäßig'#'Ist entworfen, um die Zeile zu überspringen
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:]

#Initialisierung von Gewicht / Bias
W1 = np.random.randn(4, HIDDEN_LAYER_SIZE) * np.sqrt(2 / 4)  #Anfangswert von He(Verwenden Sie dies für ReLU)
W2 = np.random.randn(HIDDEN_LAYER_SIZE, 3) * np.sqrt(2 / HIDDEN_LAYER_SIZE)
b1 = np.zeros(HIDDEN_LAYER_SIZE)  #Der Anfangswert ist Null. * Ich kenne den Grund nicht, weil ich Deep Learning aus Null gesehen habe
b2 = np.zeros(3)

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

#Softmax-Funktion * Ich weiß nicht, wie ich diese Funktion implementieren soll, da ich nur das Netz gesehen habe.
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

#Kreuzentropiefehler
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

#Vorwärtsausbreitung
def forward(x):
    global W1, W2, b1, b2
    return softmax(np.dot(relu(np.dot(x, W1) + b1), W2) + b2)

#Testergebnisse testen
test_y = forward(test_x)
print((test_y.argmax(axis=1) == test_t.argmax(axis=1)).sum(), '/', 150 - TRAIN_DATA_SIZE)

#Lernschleife
for i in range(ITERS_NUM):
    #Weiterleitung mit Datenspeicherung
    y1 = np.dot(train_x, W1) + b1
    y2 = relu(y1)
    train_y = softmax(np.dot(y2, W2) + b2)

    #Berechnung der Verlustfunktion
    L = cross_entropy_error(train_y, train_t)

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

    #Gradientenberechnung
    #Verwenden Sie die Formel aus dem Berechnungsdiagramm
    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)

    #Parameteraktualisierung
    W1 = W1 - LEARNING_RATE * W1_gradient
    W2 = W2 - LEARNING_RATE * W2_gradient
    b1 = b1 - LEARNING_RATE * b1_gradient
    b2 = b2 - LEARNING_RATE * b2_gradient

#Ergebnisanzeige

#L-Wert der endgültigen Trainingsdaten
L = cross_entropy_error(forward(train_x), train_t)
print(L)

#Testergebnisse testen
test_y = forward(test_x)
print((test_y.argmax(axis=1) == test_t.argmax(axis=1)).sum(), '/', 150 - TRAIN_DATA_SIZE)