Multi Layer Perceptron für Deep Learning (Deep Learning mit Python; MPS Yokohama Deep Learning Series)

Zweck

Erstellen Sie MLP (Multi Layer Perceptron) in Python3 nur mit Numpy und Scipy. Darüber hinaus werden wir als aktuelles Beispiel ein MLP erstellen, das handschriftliche Zahlenbilder mithilfe der handschriftlichen Zahlendatenbank MNIST klassifiziert.

Umgebung

Hinweis

Dieser Artikel ist eine Veranstaltung von MPS (Morning Project Samurai) Yokohama, die am 23. Juli 2016 stattfindet Deep Learning (mit Python) Vol. 10 Dieser Artikel wurde geschrieben für: //mpsamurai.doorkeeper.jp/events/49018). Ich würde mich freuen, wenn Sie Fragen oder Anregungen stellen könnten.

MLP (Multi Layer Perceptron)

Betrachten Sie zunächst einen einfachen MLP, wie in der folgenden Abbildung gezeigt. Tatsächlich sind alle Knoten der Schicht $ i + 1 $ und der Schicht $ i $ vollständig verbunden, aber der Klarheit halber wird nur ein Teil der Verbindung gezeichnet.

Hier sind die Symbole wie folgt definiert.

• $ s_ {ij} $: Zustand des $ j $ -ten Knotens der Schicht $ i $
• $ w_ {ikj} $: Gewichtung der $ j $ -ten Ausgabe der Schicht $ i-1 $, die in den $ k $ -ten Knoten der Schicht $ i $ eingegeben wurde
• $ f_ {i} $: AF (Aktivierungsfunktion) der Schicht $ i $
• $ y_ {ij} $: Ausgabe des $ j $ -ten Knotens der Schicht $ i $
• E: EF (Error Function)

FP (Forward Propagation)

Die FP von Schicht $ i-1 $ zu Schicht $ i $ sieht folgendermaßen aus:

y_{i} = f_{i}(W_{i}y_{i-1} + b_{i-1})

Hier sei $ y_ {i} = (y_ {ij}) $, $ W_ {i} = (w_ {ikj}) $, $ b_ {i} = (b_ {ij}) $.

Der Python-Code für ein zweischichtiges MLP-FP mit drei Eingängen und einem Ausgang sieht folgendermaßen aus:

import numpy as np


# activation function
def sigmoid(s):
    return 1/(1 + np.exp(-s))


# x: Input vector, W: Weight matrix, b: Bias, y: Output vector
x = np.random.randn(3, 1)
W = np.random.randn(1, 3)
b = np.random.randn(1, 1)
y = sigmoid(W @ x + b)

Wenn Sie eine Klassenebene definieren, die die obige Operation als Methode hat, können Sie einfach einen MLP erstellen. Das Folgende ist ein Beispiel für ein Netzwerk, das zusätzlich zur Eingangsschicht und zur Ausgangsschicht eine Zwischenschicht aufweist.

from scipy import misc
import numpy as np


class Layer:
    def __init__(self, W, b, f):
        self._W = W
        self._b = b
        self._f = f

    def propagate_forward(self, x):
        return self._f(self._W @ x + self._b)


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


if __name__ == '__main__':
    # Input vector (Layer 0)
    x = np.random.randn(3, 1)

    # Middle layer (Layer 1)
    W1 = np.random.randn(3, 3)
    b1 = np.random.randn(3, 1)
    layer1 = Layer(W1, b1, sigmoid)

    # Output layer (Layer 2)
    W2 = np.random.randn(3, 3)
    b2 = np.random.randn(3 ,1)
    layer2 = Layer(W2, b2, sigmoid)

    # FP
    y1 = layer1.propagate_forward(x)
    y2 = layer2.propagate_forward(y1)

    print(y2)

Zu diesem Zeitpunkt haben Sie die Konfiguration des MLP und die Ausgabe für einige Eingaben des MLP. Das Folgende ist ein Beispiel, in dem die handschriftliche Nummer 9, wie in der folgenden Abbildung gezeigt, als Eingabe angegeben wird.

from scipy import misc
import numpy as np
from matplotlib import pyplot as plt


class Layer:
    def __init__(self, W, b, f):
        self._W = W
        self._b = b
        self._f = f

    def propagate_forward(self, x):
        return self._f(self._W @ x + self._b)


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


if __name__ == '__main__':
    # Input vector (Layer 0)
    x = misc.imread('img/9.png', flatten=True).flatten()
    x = x.reshape((len(x), 1))

    # Middle layer (Layer 1)
    n_output_1 = len(x)
    W1 = np.random.randn(n_output_1, len(x))
    b1 = np.random.randn(n_output_1, 1)
    layer1 = Layer(W1, b1, sigmoid)

    # Output layer (Layer 2)
    n_output_2 = 10
    W2 = np.random.randn(n_output_2, n_output_1)
    b2 = np.random.randn(n_output_2, 1)
    layer2 = Layer(W2, b2, sigmoid)

    # FP
    y1 = layer1.propagate_forward(x)
    y2 = layer2.propagate_forward(y1)

    hist_W1, bins_W1 = np.histogram(W1.flatten())
    hist_W2, bins_W2 = np.histogram(W2.flatten())

    # Draw bar chart
    index = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    plt.title('Prediction')
    plt.bar(index , y2.flatten(), align="center")
    plt.xticks(index, index)
    plt.show()

Da wir die Sigmoid-Funktion für die Aktivierungsfunktion verwenden, liegt die Ausgabe der 10 Knoten in der Ausgabeschicht zwischen 0 und 1. Unter der Annahme, dass die Ausgabe des $ i $ -ten Knotens der Ausgabeschicht die Wahrscheinlichkeit darstellt, dass das Eingabebild die Zahl $ i $ ist, sagt das obige Ergebnis voraus, dass die Wahrscheinlichkeit, 2, 6 oder 7 zu sein, die höchste ist. , Nutzlos.

EF (Error Function)

EF ist ein Index, der misst, wie weit der Zustand von MLP vom Idealzustand entfernt ist. Zum Beispiel ist im Fall der oben erwähnten handschriftlichen Bilderkennung die richtige Antwort 9, und es ist ideal, das Folgende als Ausgabe zu erhalten.

y_{2} = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0)^{T}

SE (Squared Error) ist eine der häufig verwendeten Fehlerfunktionen und wird wie folgt ausgedrückt.

E = \frac{1}{2}\sum_{j} (t_{j} - y_{ij})^{2} = \frac{1}{2}(t-y_{i})^{T}(t-y_{i})

Der Code zum Finden der SE bei Eingabe einer handschriftlichen 9 ist unten dargestellt.

from scipy import misc
import numpy as np


class Layer:
    def __init__(self, W, b, f):
        self._W = W
        self._b = b
        self._f = f

    def propagate_forward(self, x):
        return self._f(self._W @ x + self._b)


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


def se(t, y):
    return ((t - y).T @ (t-y)).flatten()[0]/2


if __name__ == '__main__':
    # Input vector (Layer 0)
    x = misc.imread('img/9.png', flatten=True).flatten()
    x = x.reshape((len(x), 1))

    # Middle layer (Layer 1)
    n_output_1 = len(x)
    W1 = np.random.randn(n_output_1, len(x))
    b1 = np.random.randn(n_output_1, 1)
    layer1 = Layer(W1, b1, sigmoid)

    # Output layer (Layer 2)
    n_output_2 = 10
    W2 = np.random.randn(n_output_2, n_output_1)
    b2 = np.random.randn(n_output_2, 1)
    layer2 = Layer(W2, b2, sigmoid)

    # FP
    y1 = layer1.propagate_forward(x)
    y2 = layer2.propagate_forward(y1)

    # Calculate SE
    t = np.zeros(shape=(10, 1))
    t[9, 0] = 1.0
    e = se(t, y2)
    print(e)

Lernen mit BP (Backward Propagation)

BP soll Informationen in die entgegengesetzte Richtung des Netzwerks verbreiten. Das Lernen mit BP erfordert zwei Schritte: Die zum Lernen erforderlichen Informationen werden mit BP in die entgegengesetzte Richtung weitergegeben, und das eigentliche Lernen wird mit diesen Informationen durchgeführt.

Beim MLP-Training wird die Tatsache verwendet, dass sich der EF-Gradient in dem Bereich befindet, in dem der gewünschte Parameter die Domäne ist, und durch Bewegen des Parameters in die entgegengesetzte Richtung wird der EF-Wert am stärksten in der Nähe des aktuellen Parameters verringert. Machen. BP wird verwendet, um die Informationen zu verbreiten, die zur effizienten Berechnung dieses Gradienten erforderlich sind.

Lernen der Ausgabeschicht

Betrachten Sie zunächst das Erlernen der Ausgabeschicht eines dreischichtigen MLP.

Der Parameter, den Sie anpassen möchten, ist das Gewicht $ w_ {2ji} $. Wenn Sie also eine teilweise Differenzierung von EF $ E $ durchführen, erhalten Sie die folgende Gleichung.

\frac{\partial{E}}{\partial{w_{2ji}}} = 
\frac{\partial{E}}{\partial{y_{2j}}}
\frac{\partial{y_{2j}}}{\partial{s_{2j}}}
\frac{\partial{s_{2j}}}{\partial{w_{2ji}}}

Hier erfahren Sie, wie sich $ E $ ändert, wenn Sie $ w_ {2ji} $ ändern, und wie sich $ s_ {2j} $ ändert, wenn Sie $ w_ {2ji} $ ändern Finden Sie dann heraus, wie sich $ y_ {2j} $ ändert, wenn Sie $ s_ {2j} $ ändern, und schließlich $, wenn Sie $ y_ {2j} $ ändern Es zeigt die Beziehung, die wir untersuchen sollten, wie sich E $ ändert, was im Vergleich zum MLP-Diagramm intuitiv ist.

Hier wird es wie folgt eingestellt.

\frac{\partial{E}}{\partial{y_{2j}}}\frac{\partial{y_{2j}}}{\partial{s_{2j}}} = \delta_{2j}

Die folgende Gleichung kann auch aus $ s_ {2j} = \ sum_ {i} w_ {2ji} y_ {1i} $ erhalten werden.

\frac{\partial{s_{2j}}}{\partial{w_{2ji}}} = y_{1i}

Die folgenden Gleichungen werden durch Kombinieren der vorherigen Gleichungen erhalten.

\frac{\partial{E}}{\partial{w_{2ji}}} = \delta_{2j}y_{1i}

Das Lernen kann mit der folgenden Aktualisierungsformel erfolgen. Hier bedeutet der Pfeil in der Formel, dass die Variable auf der linken Seite durch die rechte Seite ersetzt wird. Außerdem ist $ \ epsilon $ ein Hyperparameter, der als Lernrate bezeichnet wird. Durch Anpassen dieses Wertes kann die Lerngeschwindigkeit erhöht oder verringert werden.

w_{2ji} \leftarrow w_{2ji} - \epsilon \delta_{2j}y_{1i}

Hier setzen Sie es wie folgt:

\delta_{2} = (\delta_{2j})

Die folgende Gleichung ist eine Zusammenfassung der bisherigen Diskussionen in Form einer Matrix.

\Delta W_{2} = (\frac{\partial{E}}{\partial{w_{2ji}}}) 
= \delta_{2}y_{1}^{T}

W_{2} \leftarrow W_{2} - \epsilon \Delta W_{2}

Wenn der Bias-Term auf die gleiche Weise betrachtet wird, kann die folgende Gleichung erhalten werden.

\frac{\partial{E}}{\partial{b_{2j}}} = \delta_{2j}

Daher lautet die Aktualisierungsformel für den Bias-Term wie folgt.

b_{2} \leftarrow b_{2} - \epsilon \delta_{2}

Insbesondere wird ein Beispiel gezeigt, das die Sigmoidfunktion als AF und SE als EF verwendet.

\frac{\partial{E}}{\partial{y_{2j}}} = -(t_{j}-y_{2j})

\frac{\partial{y_{2j}}}{\partial{s_{2j}}} = y_{2j}(1-y_{2j})

Daher wird die folgende Gleichung erhalten.

\delta_{2j} = -(t_{j}-y_{2j})y_{2j}(1-y_{2j})

Mit diesem $ \ delta_ {2} = (\ delta_ {2j}) $ können sowohl Gewichts- als auch Bias-Parameter trainiert werden.

Unten ist der Code, mit dem der dreischichtige MLP die Erkennung des handgeschriebenen Zeichens 9 nur in der Ausgabeschicht lernen kann.

from scipy import misc
import numpy as np
from matplotlib import pyplot as plt


class Layer:
    def __init__(self, W, b, f):
        self._W = W
        self._b = b
        self._f = f

    def propagate_forward(self, x):
        return self._f(self._W @ x + self._b)


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


def d_sigmoid(y):
    return y * (1 - y)


def se(t, y):
    return ((t - y).T @ (t-y)).flatten()[0]/2


def d_se(t, y):
    return -(t - y)


if __name__ == '__main__':
    # Input vector (Layer 0)
    x = misc.imread('img/9.png', flatten=True).flatten()
    x = x.reshape((len(x), 1))

    # Middle layer (Layer 1)
    n_output_1 = len(x)
    W1 = np.random.randn(n_output_1, len(x))
    b1 = np.random.randn(n_output_1, 1)
    layer1 = Layer(W1, b1, sigmoid)

    # Output layer (Layer 2)
    n_output_2 = 10
    W2 = np.random.randn(n_output_2, n_output_1)
    b2 = np.random.randn(n_output_2, 1)
    layer2 = Layer(W2, b2, sigmoid)

    # Training datum
    t = np.zeros(shape=(10, 1))
    t[9, 0] = 1.0

    # FP, BP and learning
    epsilon = 0.1
    se_history = []
    delta2_history = []
    for i in range(0, 100):
        # FP
        y1 = layer1.propagate_forward(x)
        y2 = layer2.propagate_forward(y1)

        # Calculate and store SE
        se_history.append(se(t, y2))

        # BP and learning
        delta2 = d_se(t, y2) * d_sigmoid(y2)
        Delta_W2 = delta2 @ y1.T
        layer2._W -= epsilon * Delta_W2
        layer2._b -= epsilon * delta2

        # Store delta2 history
        delta2_history.append(np.linalg.norm(delta2))

    y1 = layer1.propagate_forward(x)
    y2 = layer2.propagate_forward(y1)

    # Draw SE history
    plt.figure()
    plt.title('SE History')
    plt.plot(range(len(se_history)), se_history)

    # Draw delta2 history
    plt.figure()
    plt.title('delta2 history')
    plt.plot(range(len(delta2_history)), delta2_history)

    # Draw bar chart
    index = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    plt.figure()
    plt.title('Prediction')
    plt.bar(index, y2.flatten(), align="center")
    plt.xticks(index, index)

    plt.show()

Die folgende Abbildung zeigt den Übergang von SE beim 100-maligen Training. Es ist ersichtlich, dass die SE in den frühen Phasen des Lernens erheblich gesunken ist. Es ist auch zu sehen, dass der Lerneffekt nach dem 5. Mal kaum zum Tragen gekommen ist.

Um die Ursache zu bestätigen, wird unten das Diagramm mit der Größe von $ \ delta_ {2} $ angezeigt. Ab dem 5. Mal können Sie sehen, dass die Größe fast $ 0 $ beträgt.

Die MLP-Ausgabe zu diesem Zeitpunkt ist wie folgt.

Lernen in der mittleren Schicht

Betrachten Sie als nächstes das Lernen der mittleren Schicht des 3-Schicht-MLP. Unten sehen Sie ein weiteres Diagramm des 3-Schicht-MLP.

Wie beim Training der Ausgabeschicht wird die EF zunächst teilweise durch das Gewicht $ w_ {1ih} $ unterschieden, das Sie trainieren möchten. Wenn Sie hier beispielsweise $ w_ {100} $ ändern, wirkt sich diese Änderung auf $ s_ {10} $ und dann auf $ y_ {10} $ aus, was sich auf alle Knoten in der Ausgabeebene auswirkt. Beeinflusst $ s_ {2j} $, beeinflusst deren Ausgabe $ y_ {2j} $ und beeinflusst letztendlich den Wert von EF durch sie. Unter Berücksichtigung dieser Tatsache werden wir die partiellen Differentialgleichungen entwickeln und organisieren.

\begin{eqnarray}
\frac{\partial{E}}{\partial{w_{1ih}}} 
&=& \sum_{j}\frac{\partial{E}}{\partial{y_{2j}}}
\frac{\partial{y_{2j}}}{\partial{s_{2j}}}
\frac{\partial{s_{2j}}}{\partial{y_{1i}}}
\frac{\partial{y_{1i}}}{\partial{s_{1i}}}
\frac{\partial{s_{1i}}}{\partial{w_{1ih}}}\\

&=& (\sum_{j}\frac{\partial{E}}{\partial{y_{2j}}}
\frac{\partial{y_{2j}}}{\partial{s_{2j}}}
\frac{\partial{s_{2j}}}{\partial{y_{1i}}})
\frac{\partial{y_{1i}}}{\partial{s_{1i}}}
\frac{\partial{s_{1i}}}{\partial{w_{1ih}}}\\

&=&(\sum_{j}\delta_{2j} w_{2ji})
\frac{\partial{y_{1i}}}{\partial{s_{1i}}}y_{0h}\\

&=&\delta_{1i}y_{0h}
\end{eqnarray}

Hier wird $ \ delta_ {1i} $ wie folgt gesetzt.

\delta_{1i} = (\sum_{j}\delta_{2j} w_{2ji})
\frac{\partial{y_{1i}}}{\partial{s_{1i}}}

Es ist zu beachten, dass die am Ende der obigen Gleichungstransformation erhaltene Gleichung genau die gleiche ist wie die Gleichung, die abgeleitet wird, wenn das Lernen der Gewichte der Ausgabeschicht berücksichtigt wird. Drucken Sie diese Formeln erneut aus.

\begin{eqnarray}
\frac{\partial{E}}{\partial{w_{2ji}}} &=& \delta_{2j}y_{1i}\\
\frac{\partial{E}}{\partial{w_{1ih}}} &=& \delta_{1i}y_{0h}
\end{eqnarray}

Die obere wird zum Lernen der Ausgabeschicht verwendet, und die untere wird dieses Mal zum Lernen der mittleren Schicht verwendet.

Beachten Sie auch, dass $ \ delta_ {1i} $ auf dem $ \ delta_ {2j} $ basiert, das zum Trainieren der Ausgabeschicht gefunden wurde. Mit anderen Worten, wenn Sie das in der Ausgabeschicht gefundene $ \ delta_ {2j} $ kennen (wenn es von der Ausgabeschicht weitergegeben wird), können Sie das $ \ delta_ {1i} $ in der mittleren Ebene ohne komplizierte Berechnungen finden. Darauf aufbauend können Sie die mittlere Ebene lernen. Beim MLP-Lernen wird dieses $ \ delta $ als Fehler bezeichnet, und seine Weitergabe wird als BP bezeichnet.

Das Lernen der Gewichte der mittleren Schicht wird unter Verwendung einer Matrixdarstellung organisiert.

\delta_{1} = W_{2}^{T} \circ \frac{\partial{y_{1}}}{\partial{s_{1}}}

Wobei $ \ circ $ das Adamal-Produkt darstellt. Das Adamar-Produkt ist eine Multiplikation für jedes Element der Matrix.

\Delta W_{1} = \delta_{1} y_{0}^T

Dabei ist $ y_ {0} $ ein Vektor, der aus den Ausgaben jedes Knotens in der Eingabeebene besteht. Die Formel zum Aktualisieren von Gewichten durch Lernen lautet wie folgt.

W_{1} \leftarrow W_{1} - \epsilon \Delta W_{1}

Bitte versuchen Sie, den Bias-Begriff selbst abzuleiten.

Erstellen eines MLP zur Klassifizierung handgeschriebener numerischer Bilder

Basierend auf der bisherigen Diskussion lernt der Code, mit dem der 3-Schicht-MLP die Klassifizierung handgeschriebener Zahlen mithilfe einer Datenbank handgeschriebener Zahlen mit dem Namen MNIST lernen soll. Es ist unten gezeigt. Nehmen wir wie zuvor an, dass die Ausgabeschicht 10 Knoten hat und der $ i $ -te Knoten die Wahrscheinlichkeit darstellt, dass die in das gegebene Bild geschriebene Zahl $ i $ ist. Dieses Mal wird die Knotennummer mit der höchsten Wahrscheinlichkeit als endgültiges Erkennungsergebnis verwendet.

MNIST liefert 600 Millionen handgeschriebene Zahlenbilder mit Beschriftungen als Lehrerdaten, diesmal unter Verwendung der ersten 1000 dieser Daten für das Training und der anderen als Testdaten. Die Anzahl der Lernvorgänge wird auf 400.000 Mal eingestellt, indem die obigen Daten 400 Mal wiederholt verwendet werden.

import numpy as np
from matplotlib import pyplot as plt
from tqdm import tqdm


class Layer:
    def __init__(self, W, b, f):
        self._W = W
        self._b = b
        self._f = f

    def propagate_forward(self, x):
        return self._f(self._W @ x + self._b)


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


def d_sigmoid(y):
    return y * (1 - y)


def se(t, y):
    return ((t - y).T @ (t - y)).flatten()[0] / 2.0


def d_se(t, y):
    return -(t - y)


def ma(history, n):
    return np.array([0, ] * (n - 1) + [np.average(history[i - n: i]) for i in range(n, len(history) + 1)])


if __name__ == '__main__':
    from mnist import MNIST

    # Load MNIST dataset
    mndata = MNIST('./mnist')
    train_img, train_label = mndata.load_training()
    train_img = np.array(train_img, dtype=float)/255.0
    train_label = np.array(train_label, dtype=float)

    # Input vector (Layer 0)
    n_output_0 = len(train_img[0])

    # Middle layer (Layer 1)
    n_output_1 = 200
    W1 = np.random.randn(n_output_1, n_output_0)
    b1 = np.random.randn(n_output_1, 1)
    layer1 = Layer(W1, b1, sigmoid)

    # Output layer (Layer 2)
    n_output_2 = 10
    W2 = np.random.randn(n_output_2, n_output_1)
    b2 = np.random.randn(n_output_2, 1)
    layer2 = Layer(W2, b2, sigmoid)

    # FP, BP and learning
    epsilon = 0.15
    n_training_data = 1000
    se_history = []
    y1_history = []
    y2_history = []
    W1_history = []
    W2_history = []
    cpr_history = []
    for loop in range(400):
        for i in tqdm(range(n_training_data)):
            # Store W1 and W2 history
            W1_history.append(np.linalg.norm(layer1._W))
            W2_history.append(np.linalg.norm(layer2._W))

            # FP
            x = train_img[i].reshape(len(train_img[i]), 1)
            y1 = layer1.propagate_forward(x)
            y2 = layer2.propagate_forward(y1)

            # Store y1 and y2
            y1_history.append(y1)
            y2_history.append(y2)

            # Training datum
            t = np.zeros(shape=(10, 1))
            t[train_label[i], 0] = 1.0

            # Calculate and store SE
            se_history.append(se(t, y2))

            # BP
            delta2 = d_se(t, y2) * d_sigmoid(y2)
            delta1 = layer2._W.T @ delta2 * d_sigmoid(y1)

            # Learning
            Delta_W2 = delta2 @ y1.T
            layer2._W -= epsilon * Delta_W2
            layer2._b -= epsilon * delta2

            Delta_W1 = delta1 @ x.T
            layer1._W -= epsilon * Delta_W1
            layer1._b -= epsilon * delta1

        # FP to evaluate correct prediction rate
        n_correct_prediction = 0
        n_prediction = 0
        for _i in np.random.choice(np.arange(n_training_data, train_img.shape[0]), 100):
            _x = train_img[_i].reshape(len(train_img[_i]), 1)
            _y1 = layer1.propagate_forward(_x)
            _y2 = layer2.propagate_forward(_y1)

            n_prediction += 1
            if train_label[_i] == np.argmax(_y2):
                n_correct_prediction += 1
        cpr_history.append(n_correct_prediction/n_prediction)

    # Draw W1
    plt.figure()
    plt.title('W1 history')
    plt.plot(range(len(W1_history)), W1_history)

    # Draw W2
    plt.figure()
    plt.title('W2 history')
    plt.plot(range(len(W2_history)), W2_history)

    # Draw SE history and its moving average
    plt.figure()
    plt.title('SE History')
    plt.plot(range(len(se_history)), se_history, color='green')
    plt.plot(range(len(se_history)), ma(se_history, 100), color='red')

    # Draw CPR history
    plt.figure()
    plt.title('CPR')
    plt.plot(range(len(cpr_history)), cpr_history)

    plt.show()

Die folgende Abbildung zeigt die Änderung der SE von MLP mit der Anzahl der Lernvorgänge auf der horizontalen Achse. Grün steht für den Wert von SE, wenn eine Daten trainiert und dann eine andere Daten angegeben werden. Rot ist der gleitende Durchschnitt der grünen Reihe. Da durchschnittlich 100 Daten verwendet werden, handelt es sich um eine Reihe von durchschnittlichen SE-Werten, die durch 100 Trainingseinheiten erhalten wurden. Wenn man sich diese Figur ansieht, kann man sehen, dass die SE, die durch jedes Lernen erhalten wird, mit jedem Lernen stark vibriert, aber im Durchschnitt kleiner wird.

Die folgende Abbildung zeigt die Änderung der Erkennungsrate handgeschriebener Zahlen mit der Anzahl der Lernvorgänge auf der horizontalen Achse. Da die Vorhersagegenauigkeitsmessung jedoch einmal alle 1000 Lernvorgänge durchgeführt wird, ist die tatsächliche Anzahl der Lernvorgänge der Wert auf der horizontalen Achse multipliziert mit 1000. Auch hier ist zu erkennen, dass sich die Vorhersagegenauigkeit mit jedem Lernen verbessert, wenn man den gleitenden Durchschnitt betrachtet. Aus diesem Grund wird erwartet, dass es besser ist, Vorhersagen durch Kombinieren mehrerer MLPs zu treffen, als Vorhersagen mit nur einem MLP zu treffen.

Schließlich

Was wir in diesem Artikel implementiert haben, ist das grundlegende MLP und sein Lernen. Führen Sie dies in MPS Yokohama Deep Learning aus mathematischen Grundlagen (mit Python) aus, damit Sie ab dem nächsten Mal Deep Learning durchführen können. Ich werde es umbauen.

Freiwillige haben wundervolle Materialien für dieses Projekt erstellt. Bitte beziehen Sie sich auch auf sie (in keiner bestimmten Reihenfolge).

Wir haben auch Folien und Veranstaltungsvideos hochgeladen, die in früheren Veranstaltungen auf SlideShare und YouTube verwendet wurden. Wenn Sie also interessiert sind, schauen Sie bitte.

Vielen Dank

Dieses Projekt besteht aus der großartigen Zusammenarbeit vieler Menschen. Jedes Mal vermieten wir Geräte wie Veranstaltungsort, Projektor, WLAN, drehen Videos und laden sie hoch. Information Science College, Professor Muto, Sakura Internet, das Cloud-Umgebung bereitstellt, Zusammenfassung jedes Mal Saito-san, der uns genaue Ratschläge zum Management der Studiensitzung gibt, Ueno-san, der diese Studiensitzung als Leiter von MPS Yokohama, Wataru-san, leitet und uns hilft, die Studiensitzung jeden Morgen zu verwalten. Vielen Dank an Herrn Terasaki, Herrn Hirara und Herrn n-ken, die die Materialien erstellt, Fragen gestellt und jedes Mal darauf hingewiesen haben. Außerdem möchte ich Herrn Masaki danken, der seit zwei Jahren MPS-Aktivitäten unterstützt, seit ich ihn getroffen habe. Ich möchte diesen Moment nutzen, um mich zu bedanken. Freut mich, dich kennenzulernen.

2016/07/22 Junya Kaneko