Perceptron lernen

Netzwerk zu verwenden

Ein Netzwerk, das aus drei Schichten besteht: einer Eingangsschicht, einer Zwischenschicht und einer Ausgangsschicht. ・ Die Schichten sind vollständig verbunden. -Alle Neuronen geben $ 1 $ oder $ 0 $ aus.

Der Zweck von Perceptron besteht darin, das Gewicht (synaptische Last) zwischen der Zwischenschicht und der Ausgangsschicht zu lernen und das dem Eingangsmuster entsprechende Ausgangsmuster zu erzeugen.

Eingabeebene

Angenommen, Sie haben $ M $ Neuronen. Es empfängt die Eingabe von außen wie sie ist und gibt sie aus. Die Ausgabe des $ i $ -ten Neurons wird durch die folgende Formel ausgedrückt. $output_i = input_i$

Mittelschicht

Angenommen, Sie haben $ N $ Neuronen. Die Eingabe für das $ j $ -te Neuron in der mittleren Schicht ist die Summe der Ausgabewerte aller Neuronen der Eingabeschicht multipliziert mit der synaptischen Last $ w_ {i, j} . $input_j=\sum_{i=1}^{M}{w_{i,j}output_i}$$

Stellen Sie dann den Schwellenwert $ \ theta_j $ für das von jedem Neuron der mittleren Schicht empfangene Signal ein und reduzieren Sie ihn um diesen Betrag. $input_j-\theta_j$

Da die Ausgabe nur $ 0 $ oder $ 1 $ ist, setzen Sie die Ausgabefunktion $ f (x) $. Daher wird der Ausgabewert des $ j $ -ten Neurons in der mittleren Schicht durch die folgende Formel ausgedrückt. $output_j = f(input_j-\theta_j)$

f(u) = \left\{
\begin{array}{ll}
1 & (u \gt 0) \\
0 & (u \leq 0)
\end{array}
\right.

Ausgabeschicht

Die Eingabe der Ausgabeschicht ist wie die Eingabe der mittleren Schicht der Ausgabewert aller Neuronen in der vorherigen Schicht multipliziert mit der synaptischen Last. Die Anzahl der Neuronen in der Ausgabeschicht sei $ 1 $.

input_o=\sum_{j=1}^{N}{w_{j,o}output_j}

Die Ausgabe der Ausgabeschicht ist das Ergebnis der Anwendung von $ f (x) $ auf den Wert, der durch Subtrahieren des Schwellenwerts von der Eingabe wie in der Zwischenschicht erhalten wird.

output_o=f(input_o-\theta_o)

f(u) = \left\{
\begin{array}{ll}
1 & (u \gt 0) \\
0 & (u \leq 0)
\end{array}
\right.

Lernen

Während des Trainings wird nur die synaptische Last $ w_ {j, o} $ zwischen der Ausgabeschicht und der Zwischenschicht aktualisiert, ohne andere Parameter zu ändern.

\Delta w_{j,o}=\eta(t_o-output_o)output_j

w^{t+1}=w^{t}+\Delta w_{j,o}

$ \ eta $ ist die Lernrate, und es ist üblich, einen kleinen positiven Wert festzulegen. $ t_o-output_o $ ist die Differenz zwischen der Ausgabe $ t_o $ der Lehrerdaten und den tatsächlichen Ausgabedaten $ output_o $. Daher ist ersichtlich, dass die synaptische Last nur aktualisiert wird, wenn das berechnete Ergebnis und das Lehrersignal unterschiedlich sind.

Die Erklärung und der Beweis des Konvergenzsatzes von Perceptron werden hier weggelassen. Wenn Sie interessiert sind, überprüfen Sie es bitte.

Implementierung

Parametereinstellungen

Eingabedaten
Angenommen, eine Funktion gibt $ 1 $ für $ x \ gt y $ und $ 0 $ für $ x \ leq y $ für ein ganzzahliges Paar von $ (x, y) $ zwischen $ 0 $ und $ 15 $ zurück.
Wir haben $ 2000 $ Stücke solcher Daten vorbereitet.
Die Hälfte der Daten dient dem Training und die Hälfte dem Testen. --Netzwerkstruktur
Eingabeebene
Anzahl der Neuronen: $ 8 $
Stellen Sie $ 16x + y $ binär mit $ 8 $ dar und übergeben Sie jede Ziffer an das Neuron --Mittelschicht
Anzahl der Neuronen: $ 30 $ (entsprechend eingestellt, es macht Spaß zu experimentieren) --Ausgabeschicht
Anzahl der Neuronen: $ 1 $ --Synapse laden
$ [-0.005,0.005) $ einheitliche Zufallszahl
Andere Parameter
Anzahl der Experimente $ 200 $
Lernrate: $ \ eta = 10 ^ {-4} $

Code

Bibliotheksinstallation und Eingabepfadeinstellung

import numpy as np
import matplotlib.pyplot as plt

PATH_X = "./../input_x.npy"
PATH_Y = "./../input_y.npy"

Konvertieren Sie Eingabedaten von $ (x, y) $ in $ 0 $ und $ 1 $ Spalten mit einer Länge von $ 8 $

def to_input(data):
    x = data[0]
    y = data[1]
    n = x * 16 + y
    return np.array([int(k) for k in format(n, '08b')])

Perceptron-Klasse __Hinweis! __ Die Lastberechnung im Programm wird unter Berücksichtigung der oben erläuterten Formel als Vektor berechnet.

class Perceptron:
    def __init__(self, m, n, o):
        # decide initial weight [-0.005,0.005)
        #Ich habe 1 hinzugefügt, um den Schwellenwert leicht zu handhaben
        self.w_IM = np.random.rand(n,m+1) - 0.5
        self.w_IM = self.w_IM / 100
        self.w_MO = np.random.rand(o,n+1) - 0.5
        self.w_MO = self.w_MO / 100

    # calculate accuracy
    def get_acc(self, x, y):
        ok = 0
        for i in range(len(x)):
            #Ich füge ein Neuron hinzu, das immer 1 ausgibt
            mid_in = np.inner(np.append(x[i],1.), self.w_IM)
            mid_out = np.array([int(k > 0) for k in mid_in])
            #Ich füge ein Neuron hinzu, das immer 1 ausgibt
            out_in = np.inner(np.append(mid_out,1.), self.w_MO)
            ok += int(int(out_in[0] > 0) == y[i])
        return ok / len(x)

    def learn(self, train_x, train_y, eta = 0.00001):
        #Ich füge ein Neuron hinzu, das immer 1 ausgibt
        mid_in = np.inner(np.append(train_x,1.), self.w_IM)
        mid_out = np.array([int(k > 0) for k in mid_in])
        #Ich füge ein Neuron hinzu, das immer 1 ausgibt
　      out_in = np.inner(np.append(mid_out,1.), self.w_MO)
        out = int(out_in[0] > 0)

        #Aktualisieren der Last aus den Ausgabe- und Lehrerdatenwerten
        self.w_MO[0,:-1] = self.w_MO[0,:-1] + eta * (train_y - out) * mid_out

Parameter einstellen und Ergebnisdiagramm zeichnen

def main():
    # read datas
    x = np.load(PATH_X)
    y = np.load(PATH_Y)
    # split datas
    train_x, test_x = np.split(x, 2)
    train_y, test_y = np.split(y, 2)
    # preprocess - transfer data into inputs
    datas = np.array([to_input(k) for k in train_x])
    tests = np.array([to_input(k) for k in test_x])
    # number of neurons input layer
    m = 8
    # number of neurons mid layer
    n = 10
    # number of neurons output layer
    o = 1
    # define the perceptron
    P = Perceptron(m,n,o)
    
    # learning time
    N = 10
    cnt = 0

    x = np.linspace(0,200,200)
    acc_train = np.copy(x)
    acc_test = np.copy(x)
    while True:
        acc = P.get_acc(datas, train_y)
        acc_train[cnt] = acc
        acc = P.get_acc(tests, test_y)
        acc_test[cnt] = acc
        print("Try ", cnt, ": ", acc)
        cnt += 1
        for i in range(len(datas)):
            P.learn(datas[i], train_y[i])
        if cnt >= 200:
            break
    plt.plot(x,acc_train,label="train")
    plt.plot(x,acc_test,label="test")
    plt.savefig("result.png ")

if __name__ == "__main__":
    main()

Es wird auch auf Github hochgeladen. https://github.com/xuelei7/NeuralNetwork/tree/master/Perceptron

Ergebnis

Die horizontale Achse ist die Anzahl der Versuche und die vertikale Achse ist die richtige Antwortrate.

Für $ 30 $ Mittelschichtneuronen:

Für $ 100 $ Anzahl der Neuronen der mittleren Schicht:

abschließend

Wenn Sie etwas finden, das nicht angemessen ist, möchten wir es korrigieren. Wir entschuldigen uns für die Unannehmlichkeiten, wenden uns jedoch bitte an den Autor.

Referenzmaterial

"Neuronales Netz", Yasunari Yoshitomi, Asakura Shoten,

[PYTHON] Perceptron Grundlagen und Implementierung