Neuronales Netzwerktraining
In diesem Teil des Artikels über die Entwicklung des einfachsten neuronalen Netzes lernen wir, wie man neuronale Netze trainiert.
Wir werden das neuronale Netzwerk trainieren, um das Problem des Findens von Mustern in einer Reihe von Zahlen zu lösen. Der Einfachheit halber sind dies die Zahlen 0 und 1.
Um ein neuronales Netzwerk zu trainieren, muss man Problembedingungen und Lösungen haben, Probleme müssen ein Problem lösen.
Die Trainingsdaten sehen so aus
Bedingung |
Antworten |
|
einer |
0 |
einer |
0 |
0 |
0 |
0 |
einer |
0 |
Sie können dieses Problem in fast allen Artikeln über das Schreiben neuronaler Netze von Grund auf sehen.
Als Ergebnis des Trainings findet das neuronale Netzwerk eine logische Verbindung zwischen einer Bedingung und einer Antwort.
Die Lösung für dieses Problem ist die erste eingegebene Nummer.
Als Bedingung für das vom neuronalen Netz zu lösende Problem sieht es so aus
Bedingung |
Antworten |
|
einer |
einer |
einer |
Beim neuronalen Netztraining geht es darum, Verluste zu reduzieren.
Je weniger Verluste, desto besser und korrekter das Ergebnis.
Um komplizierte Formeln zu vermeiden, werde ich die Prinzipien des Trainings nicht im Detail erklären, ich werde Ihnen einen mehr oder weniger klaren Code geben und die Funktionen erklären, die für das Training eines neuronalen Netzwerks erforderlich sind.
Für das Training benötigen wir die Ableitung des Sigmoid.
Sie können in Wikipedia sehen, was ein Derivat ist, und das Derivat eines Sigmoid sieht folgendermaßen aus:
Die Python-Implementierung sieht folgendermaßen aus:
def deriv_sig(x):
return sig(x) * (1 - sig(x))
Schreiben wir diesen Code in die Datei Math.py
Wir brauchen auch 2 Konstanten für das Training:
rate - Lernrate
count_learn - Anzahl der Trainingswiederholungen
count_learn , . rate .
:
rate = 0.1
count_learn = 10000
, 0 count_learn, , .
, :
def learn(self, inputs, answers):
rate = 0.1
count_learn = 10000
for o in range(count_learn):
for inputt, answer in zip(inputs, answers):
sum_n1 = self.n[0].w[0] * inputt[0] + self.n[0].w[1] * inputt[1] + self.n[0].b
n1 = sig(sum_n1)
sum_n2 = self.n[1].w[0] * inputt[0] + self.n[1].w[1] * inputt[1] + self.n[1].b
n2 = sig(sum_n2)
sum_n3 = self.n[2].w[0] * n1 + self.n[2].w[1] * n2 + self.n[2].b
n3 = sig(sum_n3)
out_res = n3
err = -2 * (answer - out_res)
err_rate = rate * err
deriv_sig_n1 = deriv_sig(sum_n1)
deriv_sig_n2 = deriv_sig(sum_n2)
deriv_sig_n3 = deriv_sig(sum_n3)
self.n[0].w[0] -= err_rate * self.n[2].w[0] * deriv_sig_n3 * inputt[0] * deriv_sig_n1
self.n[0].w[1] -= err_rate * self.n[2].w[0] * deriv_sig_n3 * inputt[1] * deriv_sig_n1
self.n[0].b -= err_rate * self.n[2].w[0] * deriv_sig_n3 * deriv_sig_n1
self.n[1].w[0] -= err_rate * self.n[2].w[1] * deriv_sig_n3 * inputt[0] * deriv_sig_n2
self.n[1].w[1] -= err_rate * self.n[2].w[1] * deriv_sig_n3 * inputt[1] * deriv_sig_n2
self.n[1].b -= err_rate * self.n[2].w[1] * deriv_sig_n3 * deriv_sig_n2
self.n[2].w[0] -= err_rate * n1 * deriv_sig_n3
self.n[2].w[1] -= err_rate * n2 * deriv_sig_n3
self.n[2].b -= err_rate * deriv_sig_n3
NeuronNet.
NeuronNet.py :
from Neuron import *
class NeuronNet:
def __init__(self):
self.n = []
for i in range(3):
self.n.append(Neuron(2))
def activate(self, inputs):
return self.n[2].activate(np.array([self.n[0].activate(inputs), self.n[1].activate(inputs)]))
def learn(self, inputs, answers):
rate = 0.1
count_learn = 10000
for o in range(count_learn):
for inputt, answer in zip(inputs, answers):
sum_n1 = self.n[0].w[0] * inputt[0] + self.n[0].w[1] * inputt[1] + self.n[0].b
n1 = sig(sum_n1)
sum_n2 = self.n[1].w[0] * inputt[0] + self.n[1].w[1] * inputt[1] + self.n[1].b
n2 = sig(sum_n2)
sum_n3 = self.n[2].w[0] * n1 + self.n[2].w[1] * n2 + self.n[2].b
n3 = sig(sum_n3)
out_res = n3
err = -2 * (answer - out_res)
err_rate = rate * err
deriv_sig_n1 = deriv_sig(sum_n1)
deriv_sig_n2 = deriv_sig(sum_n2)
deriv_sig_n3 = deriv_sig(sum_n3)
self.n[0].w[0] -= err_rate * self.n[2].w[0] * deriv_sig_n3 * inputt[0] * deriv_sig_n1
self.n[0].w[1] -= err_rate * self.n[2].w[0] * deriv_sig_n3 * inputt[1] * deriv_sig_n1
self.n[0].b -= err_rate * self.n[2].w[0] * deriv_sig_n3 * deriv_sig_n1
self.n[1].w[0] -= err_rate * self.n[2].w[1] * deriv_sig_n3 * inputt[0] * deriv_sig_n2
self.n[1].w[1] -= err_rate * self.n[2].w[1] * deriv_sig_n3 * inputt[1] * deriv_sig_n2
self.n[1].b -= err_rate * self.n[2].w[1] * deriv_sig_n3 * deriv_sig_n2
self.n[2].w[0] -= err_rate * n1 * deriv_sig_n3
self.n[2].w[1] -= err_rate * n2 * deriv_sig_n3
self.n[2].b -= err_rate * deriv_sig_n3
Math.py :
import numpy as np
def sig(x):
return 1 / (1 + np.exp(-x))
def deriv_sig(x):
return sig(x) * (1 - sig(x))
.
main.py :
learn_inputs = np.array([[1, 0], [0, 0], [0, 1]])
learn_answers = np.array([1, 0, 0])
:
net.learn(learn_inputs, learn_answers)
:
x = np.array([1, 1])
if (net.activate(x) < 0.5):
print("0")
else:
print("1")
main.py :
import numpy as np
from NeuronNet import *
net = NeuronNet()
learn_inputs = np.array([[1, 0], [0, 0], [0, 1]])
learn_answers = np.array([1, 0, 0])
net.learn(learn_inputs, learn_answers)
x = np.array([1, 1])
if (net.activate(x) < 0.5):
print("0")
else:
print("1")
:
python main.py
,
|
|
|
|
1 |
1 |
1 |
|
|
|
|
0 |
1 |
0 |
.
.