Einfaches Perceptron ist die Grundlage des maschinellen Lernens, insbesondere neuronaler Netze. Ich lerne auch, aber beginnen wir mit der Implementierung eines neuronalen Netzwerks mit einem einfachen Perceptron und arbeiten schließlich hart daran, Deep Learning zu implementieren! (Ich gebe auch mein Bestes)
Ein neuronales Netzwerk, das ein Array als Eingabe verwendet und eine Zahl 0 oder 1 zurückgibt. Dieser Algorithmus begann mit der Nachahmung von Gehirnzellen. Eine Sache, die Sie beachten sollten, ist, dass es sich nur um eine einfache Nachahmung handelt und dass sie extrem vereinfacht ist. Die einzigen mathematischen Elemente, die in Simple Perceptron vorkommen, sind Multiplikation und Addition. Es sind insgesamt 2 Zeilen mit Ausdrücken zu merken, und der Quellcode umfasst allein für den Lernalgorithmus etwa 20 Zeilen.
Dieser Artikel wird von mir nicht tief verstanden und wird langwierig sein, wenn ich einen detaillierten Lernalgorithmus beweise. Erstens ist die Anzahl der Formeln selbst gering, und Sie können sich die Formeln merken und sie so implementieren, wie sie sind. Daher werde ich nicht erklären, warum Sie mit diesem Algorithmus lernen können. Es ist nur eine Einführung, steigern Sie. Ich möchte eine ausführliche Erklärung separat veröffentlichen, wenn ich ein besseres Verständnis habe. (Ich dachte, es wäre länger, weil es Klarheit betont)
Ich werde kurz die tatsächliche Zusammensetzung der Gehirnzellen beschreiben. Die Eingabe in Gehirnzellen erfolgt über Vorsprünge, die als dendritische Vorsprünge bezeichnet werden. Die dendritischen Vorsprünge sind leicht zu übertragen und schwer zu übertragen. In einem Ausdruck ausgedrückt ist es einfach eine Multiplikation. Sei ich der Eingang und w die Leichtigkeit der Übertragung.
i \times w
Die einfache Übertragung wird als Gewicht bezeichnet und wird daher durch w dargestellt. Es gibt mehrere dendritische Vorsprünge. Selbst mit einem einfachen Perzeptron ist die Eingabe natürlich ein Array von Zahlen. Daher wird diese Berechnung für die Eingabeelemente durchgeführt. Zum Beispiel, wenn es 5 Elemente gibt
i_0 \times w_0\\
i_1 \times w_1\\
i_2 \times w_2\\
i_3 \times w_3\\
i_4 \times w_4\\
Es wird sein. Die Zahlen daneben sind Indizes. i und w entsprechen den Arrays, die im Programm platziert werden können. Es bedeutet i [0] * w [0]. Sie können sehen, dass die Anzahl der Elemente des Gewichts und die Anzahl der Elemente der Eingabe übereinstimmen und die Elemente desselben Index in jedem Array multipliziert werden.
Die Eingabe in die Gehirnzellen war jeder dendritische Prozess. Andererseits hat es nur einen Ausgang und wird Axon genannt. Die dendritischen Prozesse und Axone erstrecken sich vom sogenannten Zellkörper. Die Eingaben von jedem dendritischen Prozess verschmelzen am Zellkörper, und die Ausgabe erfolgt vom Zellkörper zu einem Axon.
Die Eingabe und Übertragung von Signalen in den dendritischen Prozess könnte einfach durch Multiplikation ausgedrückt werden, wie in der obigen Gleichung. Als nächstes muss diese Eingabe am Zellkörper zusammengeführt werden. Es wird einfach die Summe der Eingaben durch die Dendritik genommen. Mit anderen Worten, es wird realisiert, indem man sie addiert.
i_0 \times w_0 + i_1 \times w_1 + i_2 \times w_2 + i_3 \times w_3 + i_4 \times w_4
Verwenden Sie Abkürzungen, da die Formeln lang sind. Sigma wird für die Abkürzung von sum verwendet. Zum Beispiel ist die Summe von 1 bis 5 unten gezeigt.
\sum_{i=1}^{5} i = 1 + 2 + 3 + 4 + 5
sigma.py
tmp = 0
for i in range(1,6):
tmp += i
Ich habe auch den Quellcode für Python gezeigt. Bitte beziehen Sie sich auf. Sigma (Σ) ist sehr einfach. Geben Sie die Variable und den Anfangswert dieser Variablen unter dem Sigma ein. Dies ist der Teil von i = 1. Beachten Sie, dass das i hier das i im Index ist, nicht die Eingabe. Variablennamen können frei angegeben werden als i. Über dem Sigma befindet sich die Anzahl der Änderungen am Wert der Variablen i. Die Variable i wird um genau 1 erhöht. Sigma zeigt, dass sie addiert werden.
Die Formel für die Eingabe durch den dendritischen Prozess ist ebenfalls unten gezeigt. Ich benutze i als Variable für die Eingabe, also benutze stattdessen j.
\sum_{j=0}^{4} i_j \times w_j = i_0 \times w_0 + i_1 \times w_1 + i_2 \times w_2 + i_3 \times w_3 + i_4 \times w_4
sigma.py
#Es wird angenommen, dass i und w vordefiniert sind.
tmp = 0
for j in range(5):
tmp += i[j] * w[j]
Ohne Namen ist es unpraktisch, daher nennen wir diesen Wert eine gewichtete Eingabe. Der Variablenname ist vorerst z. Außerdem werden wir die Anzahl der Elemente durch n darstellen, damit wir die Anzahl der anderen Elemente als 5 verarbeiten können.
z = \sum_{j=0}^{n-1} i_j w_j
Damit ist die gewichtete Eingabeformel abgeschlossen. Damit kann die Eingabe, die Leichtigkeit der Übertragung jeder Eingabe und deren Zusammenfassung als Ausdruck ausgedrückt werden. Schließlich drückt die Formel aus, wie die Ausgabe aus dieser Summe bestimmt wird.
Wieder ahmt es echte Gehirnzellen nach. Wenn in tatsächlichen Gehirnzellen der Eingang über einem bestimmten Pegel liegt, sendet er ein Signal, und wenn er unter einem bestimmten Pegel liegt, sendet er kein Signal. Wenn ein Signal über einem bestimmten Pegel erzeugt wird, spricht man von Zündung.
Das Simple Perceptron ist ein sehr einfaches Modell. Daher ist diese Formel auch einfach. Sei z die gewichtete Eingabe und o die Ausgabe.
o =
\begin{cases}
1 & \text{if } z > 0\\
0 & \text{if } z \leqq 0
\end{cases}
step.py
#Sei z vordefiniert
if z > 0:
o = 1
elif z <= 0 :
o = 0
das ist alles. Wenn es größer als 0 ist, wird es ausgelöst (Tell 1), andernfalls wird es nicht ausgelöst (Tell 0). An diesem Punkt fragen sich diejenigen, die es richtig gelesen haben, möglicherweise, ob sie basierend auf 0 feuern sollen oder nicht. Dies liegt daran, dass eindeutig davon ausgegangen wird, dass ein negatives Signal in den Zellkörper eintritt.
Beachten Sie jedoch, dass das Simple Perceptron ein sehr einfaches Modell ist. Wenn es größer als 0 ist, wird es gezündet, aber dies ist nur eine Spezifikation zur Vereinfachung des Perceptrons. Damit ist meine Diskussion über die Ausgabe des Perceptron abgeschlossen.
Zusammenfassend lautet der Python-Code der Ausgabe von Simple Perceptron wie folgt.
output.py
#Es wird angenommen, dass i und w vordefiniert sind.
def dot(vec0,vec1):
tmp = 0
for i in range(len(vec0)):
tmp += vec0[i] * vec1[i]
return tmp
def step(num):
if num > 0:
return 1
else:
return 0
o = step(dot(i,w))
Funktionen, die 1 zurückgeben, wenn sie größer als 0 sind, werden in der Mathematik als Sprungfunktion klassifiziert. Die Funktion, die jedes Element multipliziert und die Summe nimmt, wird auch als inneres Produkt bezeichnet, das im Englischen auch als Punktprodukt bezeichnet wird. Der Funktionsname des Programms wird von hier übernommen.
output.py
step(dot(i,w))
Wenn Sie sich an die obige einzeilige Formel erinnern, sollten Sie in der Lage sein, genügend Ausgabealgorithmen zu schreiben. Hier ist eine weitere Zeile, an die Sie sich erinnern sollten: die Formel zum Lernen:
Wie eingangs erwähnt, wird in diesem Artikel nicht erläutert, warum dieser Algorithmus für das Training verwendet werden kann. Ziel ist es, es durch Implementierung zu einer Probeübung für das nächste neuronale Netzwerk zu machen. Das Ziel ist Deep Learning. (Ich habe viel erklärt ...)
Ich denke jedoch, dass es schwierig ist, sich das Ganze zu merken, deshalb möchte ich einige Erklärungen hinzufügen. Erstens ist es das Ziel von Perceptron, die richtige Ausgabe für die Eingabe zurückzugeben. Aus diesem Grund müssen Daten vorbereitet werden, die das Vorhandensein von Eingabedaten und die entsprechende Ausgabe für diese Eingabe definieren. Eine geeignete Ausgabe wird als Lehrerlabel bezeichnet.
Heutzutage ist einfaches Perzeptron das sogenannte überwachte Lernen im neuronalen Netz. Beim überwachten Lernen müssen die Daten trainiert werden, die entsprechende Ausgabe, die Sie bei der Eingabe dieser Daten sehen möchten, und das Lehreretikett. Basierend auf diesen Daten ist das Aktualisieren des Gewichts und w das Lernen im einfachen Perzeptron.
Dieses Mal werde ich am Beispiel des Trainings und der logischen Funktionsweise erklären. Die Operation und ist eine Operation, die zwei Zahlen (0 bzw. 1) empfängt, 1 ausgibt, wenn beide 1 sind, und andernfalls 0 zurückgibt, was die Basis eines Computers ist.
| a | b | a and b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Bereiten wir vorerst Trainingsdaten und Lehreretiketten vor. In diesem Bereich werden häufig x und y verwendet, um jeweils darzustellen, daher verwenden wir train_x und train_y.
data.py
train_x = [[0,0],[0,1],[1,0],[1,1]]
train_y = [0,0,0,1]
Es scheint kein besonderes Problem zu geben. Es kann ausgedrückt werden, dass 0 ausgegeben wird, wenn [0,0], [0,1], [1,0] und 1 ausgegeben wird, wenn [1,1].
Ich denke es ist ein Fehler.
Warum? Tatsächlich fehlt in den einfachen Perceptron-Erklärungen, die ich bisher gegeben habe, etwas. Die Existenz des Bias-Terms. Das ist richtig.
data.py
train_x = [[0,0,1],[0,1,1],[1,0,1],[1,1,1]]
train_y = [0,0,0,1]
1 am Ende von train_x hinzugefügt. Der Bias-Term ist ein fester Wert für alle Eingabebeispiele. Es kann anders als 1 sein, solange es fest ist (z. B. [[0,0,0,5], [0,1,0,5], [1,0,0,5], [1,1,0,5]]). Normalerweise wird jedoch 1 als Bias-Term hinzugefügt. Warum brauchen wir einen Bias-Begriff?
Nehmen wir als Beispiel den Fall, in dem der Bias-Term 1 ist. Lassen Sie uns zu diesem Zeitpunkt sehen, was mit der gewichteten Eingabe z passiert. Deshalb werden i [n] und w [n] hinzugefügt.
z = \sum_{j=0}^{n-1} i_j w_j + i_n w_n
Hier ist i [n] 1 im Bias-Term, also ist dies der Fall.
z = \sum_{j=0}^{n-1} i_j w_j + w_n
Kurz gesagt, das Hinzufügen des Bias-Terms 1 entspricht dem Hinzufügen eines Gewichts. Beim Lernen wird dieses w [n] auf die gleiche Weise aktualisiert, und als Ergebnis geht die gewichtete Eingabe z um die Variable w [n] auf und ab. Dies liegt daran, dass das Gewicht wie oben beschrieben einen negativen Wert annehmen kann. Mit anderen Worten kann durch Hinzufügen eines Vorspannungsterms die gewichtete Eingabe z zu beiden Seiten vorgespannt werden. (Bias bedeutet Bias)
In Bezug auf die tatsächliche Funktion von Gehirnzellen entspricht dies einer indirekten Änderung der Zündschwelle (Ausgabe eines Signals, wenn die Eingabe über einem bestimmten Pegel liegt (als Schwelle bezeichnet)). Natürlich ist der Schwellenwert der Schrittfunktion 0, aber wenn beispielsweise eine Vorspannung von 0,5 vorliegt, entspricht dies indirekt dem Schwellenwert, der -0,5 wird.
Wenn Sie den Schwellenwert ändern, müssen Sie feststellen, ob es einfach ist, 1 oder 0 auszugeben, damit Sie sehen können, dass dies ein wichtiger Faktor ist. Also lasst es uns voreingenommen machen. Selbst beim Lernen und wird es nicht funktionieren, wenn kein Bias-Begriff enthalten ist. Mathematisch kann erklärt werden (es scheint), dass, wenn es beim Trennen in einer Superebene keinen Abschnitt gibt, nur ein Graph gezeichnet werden kann, der durch den Ursprung verläuft, und die Ausdruckskraft verringert wird, aber ich werde ihn weglassen. Ich möchte später einen mathematischen Beweis geben.
Lassen Sie uns die Geschichte zurückgeben. Es ging darum, einfaches Perceptron zu lernen. Lernen aktualisiert Gewichte. Dazu habe ich festgestellt, dass ich eine Reihe von Ein- und Ausgängen für sie als Lehrerdaten benötige. Was müssen wir noch tun, um die Gewichte zu ändern und die richtige Ausgabe für die Eingabe zurückzugeben? Natürlich ist es das Originalgewicht.
data.py
train_x = [[0,0,1],[0,1,1],[1,0,1],[1,1,1]]
train_y = [0,0,0,1]
weight = [0,0,0]
Ich habe vorerst versucht, alle Gewichtsvektoren mit 0 zu initialisieren. Ein Gewichtsvektor ist ein Gewicht. Heutzutage wird ein Array, das nur Zahlen enthält, als Vektor bezeichnet. Wenn wir von nun an einen Vektor sagen, erkennen Sie bitte, dass dies ein Array bedeutet.
Was brauchst du noch? Um den Gewichtsvektor zu aktualisieren, scheint es notwendig zu sein, zu entscheiden, ob der Gewichtsvektor überhaupt aktualisiert werden soll. Da es offensichtlich ist, dass der Zeitpunkt, zu dem der Gewichtsvektor aktualisiert werden sollte, der Zeitpunkt ist, an dem die falsche Ausgabe ausgegeben wird, ist die Ausgabe o erforderlich.
data.py
train_x = [[0,0,1],[0,1,1],[1,0,1],[1,1,1]]
train_y = [0,0,0,1]
weight = [0,0,0]
#Beispiel: Zug_x[0]Ausgabe wenn ich bin
o = step(dot(train_x[0],weight))
Was brauchst du noch? In der Tat ist dies das Ende. Mit den obigen Daten können Sie den Gewichtsvektor aktualisieren. Es ist eine Lüge. In der Realität ist es normal, den Lernkoeffizienten einzubeziehen. Der Lernkoeffizient ist eine Zahl, die angibt, um wie viel sich das Gewicht ändert, wenn es aktualisiert wird. Selbst wenn der Lernkoeffizient 1 ist, konvergiert er (das Lernen endet ordnungsgemäß), und wenn alle Gewichtsvektoren 0 sind, ist die Häufigkeit der Konvergenz unabhängig vom Lernkoeffizienten gleich (sie scheint später in der Referenz veröffentlicht zu werden). ), Also kannst du es weglassen. Aber lassen Sie es uns vorerst einfügen.
data.py
train_x = [[0,0,1],[0,1,1],[1,0,1],[1,1,1]]
train_y = [0,0,0,1]
weight = [0,0,0]
#Beispiel: Zug_x[0]Ausgabe wenn ich bin
o = step(dot(train_x[0],weight))
#Beispiel: Lernkoeffizient
eta = 0.1
Schauen wir uns den Update-Algorithmus an. Zunächst scheint es notwendig zu sein, zu entscheiden, ob der Gewichtsvektor erhöht oder verringert werden soll, wenn die Ausgabe falsch ist. Wenn Sie 0 ausgeben möchten, sollten Sie das Gewicht reduzieren, wenn Sie 1 ausgeben, und wenn Sie 1 ausgeben möchten, sollten Sie das Gewicht erhöhen, wenn Sie 0 ausgeben. Wenn sie übereinstimmen, ändern sich die Gewichte natürlich nicht.
In diesem Fall ist der Wert, den Sie ausgeben möchten (Lehrerbezeichnung), y und die tatsächliche Ausgabe o.
y - o
Es kann ausgedrückt werden durch. In der Tabelle gezeigt.
| y | o | y - o |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | -1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Sie können ausdrücken, dass wenn o groß ist, es um -1 reduziert wird und wenn o klein ist, es um +1 erhöht wird.
Dies ist jedoch in Einheiten des gesamten Gewichtsvektors. Ich werde erklären, was das bedeutet. Die obige Formel ist der tatsächliche Code
y_o.py
#Beispiel: Trainieren, wenn der Index 0 ist_x und trainieren_Berechnen Sie basierend auf dem Element von y
y = train_y[0]
o = step(dot(train_x[0],weight))
y - o
Es wird sein. Der Punkt ist, dass y-o aus dem gesamten Gewichtsvektor berechnet wird. Dies sagt uns, ob dieser Gewichtsvektor positiv oder negativ aktualisiert werden soll, aber nicht, welches Element aktualisiert werden soll. Dies ist offensichtlich nicht gut, da bei gleichmäßiger Aktualisierung aller Gewichte alle Elemente des Gewichtsvektors den gleichen Wert haben! Was soll ich machen?
Lassen Sie uns nun auf das Verhalten von Perceptron zurückblicken. Perceptron nimmt einen Eingabevektor, multipliziert jeden mit einem Gewichtsvektor, nimmt die Summe, gibt sie dem Argument der Schrittfunktion und gibt 0 oder 1 aus. Wenn Sie also dieselbe Eingabe geben, wird natürlich dieselbe Ausgabe zurückgegeben. Und wenn Sie unterschiedliche Eingaben machen, insbesondere wenn Sie unterschiedliche Daten für das Lehreretikett angeben, ist es wünschenswert, unterschiedliche Ausgaben zurückzugeben.
Die Rückgabe unterschiedlicher Ausgänge bedeutet, dass die gewichteten Eingänge entweder auf positive oder negative Zahlen ausgerichtet sein müssen. Dies liegt daran, dass die gewichtete Eingabe durch die Schrittfunktion geleitet wird.
Wenn die Lehrerbezeichnung 1 Daten enthält, sollte sie auf eine positive Zahl vorgespannt sein, und wenn die Lehrerbezeichnung 0 ist, sollte sie auf eine negative Zahl vorgespannt sein. Mit anderen Worten, wenn man einfach denkt, müssen Gewichte sowohl positive als auch negative Gewichte haben. Sie können kein einheitliches Gewicht haben.
Und für positive Gewichte sollten Daten mit einer Lehrerbezeichnung von 1 übergeben werden, und für negative Gewichte sollten Daten mit einer Lehrerbezeichnung von 0 übergeben werden. Auf diese Weise geben Daten mit einer Lehrerbezeichnung von 1, die ein positives Gewicht überschritten hat, natürlich 1 aus, und Daten mit einer Lehrerbezeichnung von 0, die ein negatives Gewicht überschritten hat, geben natürlich 0 aus.
Selbst wenn es sich um ein positives oder ein negatives Gewicht handelt, leitet Perceptron den Eingabevektor natürlich durch alle Gewichte, sodass dies kein korrekter Ausdruck ist. Wie machst du es richtig? Stellen Sie sich nun vor, dass die Elemente des Eingabevektors eine 0 enthielten.
Da die Eingabe 0 ist, hat das der Eingabe entsprechende Gewicht keine Auswirkung, wenn das innere Produkt genommen wird. 0 x Gewicht = 0. Das heißt, wenn die Eingabe 0 ist, sind die entsprechenden Gewichte die gleichen, die bei der Berechnung der Ausgabe ignoriert werden. Es scheint, dass dies das Gewicht nicht überschritten hat.
Wenn die Eingabe 0 ist, gibt die Eingabe das Gewicht nicht weiter. Daher muss das Gewicht nicht aktualisiert werden. Beispielsweise können Daten mit einer Lehrerbezeichnung von 1 dieses Gewicht nicht durchlaufen, Daten mit einer Lehrerbezeichnung von 0 können jedoch dieses Gewicht durchlaufen. Es wird ohne Erlaubnis geändert (und in Ihre eigene Richtung), was den gegenteiligen Effekt hat.
Du weißt es schon. Wenn beim Aktualisieren des Gewichtsvektors die Eingabe 0 ist, sollte das Gewicht nicht aktualisiert werden, und wenn die Eingabe 1 ist, sollte das Gewicht aktualisiert werden. Da die Eingabe nicht unbedingt 0 oder 1 ist, können Sie einfach denken, dass die Anzahl der Gewichtsvektoraktualisierungen proportional zu dieser Eingabe ist.
Das heißt, beispielsweise ist der Aktualisierungsbetrag des Index 0 des Gewichtsvektors
(y - o) * i_0
Es wird sein. Hoppla, Sie haben vergessen, den Lernkoeffizienten anzugeben.
(y - o) * i_0 * eta
Was brauchst du noch ... Nichts erforderlich! Beim Aktualisieren von w [0] müssen alle Werte hinzugefügt werden. Wenn Sie dem neuen w [0] einen Punkt hinzufügen und ihn in der Formel ausdrücken, sieht er folgendermaßen aus.
\dot{w}_0 = w_0 + (y - o) * i_0 * eta
Setzen wir es auf j, damit es auch dann verwendet werden kann, wenn der Index nicht 0 ist.
\dot{w}_j = w_j + (y - o) * i_j * eta
Dies ist das Ende der zweiten Formel, an die Sie sich erinnern sollten. Der Rest ist ein Verdauungsspiel, bei dem Sie einfach das Programm schreiben. Vielen Dank.
Lassen Sie es uns einzeln implementieren. Es wird davon ausgegangen, dass Python gelesen werden kann. Zunächst benötigten Sie eine Funktion zur Berechnung des inneren Produkts und eine Schrittfunktion.
dot.py
def dot(vec0,vec1):
tmp = 0
for i, j in zip(vec0,vec1):
tmp += i * j
return tmp
Die Zip-Funktion ist eine Funktion, die zwei Listen zusammenstellt. Dadurch werden die Elemente der eingefügten Liste von Anfang an in i und j eingefügt. Multiplizieren Sie sie einfach und addieren Sie sie. Denken Sie an die Zip-Funktion, weil sie bequem ist.
step.py
def step(num):
if num > 0:
return 1
else:
return 0
Definieren wir mehr Ausgabe. Ich habe es Feedforward genannt. Unabhängig davon ist die Ausgabe ebenfalls akzeptabel.
feedforward.py
def feedforward(i,w):
return step(dot(i,w))
Als nächstes wird gelernt. Denken Sie an diese Formel.
\dot{w}_j = w_j + (y - o) * i_j * eta
Wenn Sie vorerst nur die Argumente schreiben, die die Funktion akzeptiert, wird dies so sein.
train.py
def train(w,i,y,eta):
pass
i und y sind Elemente von train_x und train_y. Obwohl train_x und train_y Lehrerdaten sind, werden wir jedes Element der Lehrerdaten einzeln trainieren. Dies wird als Online-Lernen, sequentielles Lernen bezeichnet. Berechnen wir vorerst o.
train.py
def train(w,i,y,eta):
o = feedforward(i,w)
Da alle w [j] aktualisiert werden müssen, drehen Sie die for-Anweisung.
train.py
def train(w,i,y,eta):
o = feedforward(i,w)
for j in range(len(w)):
w[j] = w[j] + (y - o) * i[j] * eta
return w
Bereiten Sie Lehrerdaten, Gewichtsvektor und Lernrate vor ...
data.py
train_x = [[0,0,1],[0,1,1],[1,0,1],[1,1,1]]
train_y = [0,0,0,1]
weight = [0,0,0]
eta = 0.1
Lassen Sie die Lehrerdaten einzeln lernen ...
main.py
for x,y in zip(train_x,train_y):
weight = train(weight,x,y,eta)
Wenn Sie es mehrmals wiederholen ... (Die Anzahl der Wiederholungen wird als Epoche bezeichnet.)
main.py
epoch = 100
for i in range(epoch):
for x,y in zip(train_x,train_y):
weight = train(weight,x,y,eta)
Komplett!
simple_perceptron.py
#Innenprodukt
def dot(vec0,vec1):
tmp = 0
for i, j in zip(vec0,vec1):
tmp += i * j
return tmp
#Stufenfunktion
def step(num):
if num > 0:
return 1
else:
return 0
#Ausgabe
def feedforward(i,w):
return step(dot(i,w))
#Sequentielles Lernen
def train(w,i,y,eta):
o = feedforward(i,w)
for j in range(len(w)):
w[j] = w[j] + (y - o) * i[j] * eta
return w
#Hauptverarbeitung,Lernen und.
if __name__ == "__main__":
train_x = [[0,0,1],[0,1,1],[1,0,1],[1,1,1]]
train_y = [0,0,0,1]
weight = [0,0,0]
eta = 0.1
epoch = 100
for i in range(epoch):
for x,y in zip(train_x,train_y):
weight = train(weight,x,y,eta)
#Bestätigung,0,0,0,Es ist in Ordnung, wenn 1 ausgegeben wird
for x in train_x:
print(feedforward(x,weight))
Die Eingabedaten können ein Array von Zahlen sein, dh ein beliebiger Vektor. Sie können Zahlen auch erkennen, indem Sie handgeschriebene 0- und 1-Bilder in ein eindimensionales Array (Vektor) konvertieren. Die Genauigkeit ist subtil, aber ...