Hallo! Es ist cool! !!
Dieser Artikel richtet sich an Anfänger bis zum Deep Learning.
Dieses Mal werde ich den grundlegenden Teil von Chainer erklären, einer Deep-Learning-Bibliothek für Python. Ich werde darüber schreiben, wie man ein vollständig verbundenes neuronales Netz, eine Aktivierungsfunktion, eine Optimierungsfunktion usw. aufbaut.
Die Python-Umgebung verwendet Python 3.6.7-64bit. Außerdem verwendet die Bibliothek nur Chainer.
Der in diesem Artikel gezeigte Code ist genau so. Ich empfehle daher, dass Sie versuchen, ihn von Anfang an zu erstellen, während Sie darauf verweisen.
Unten finden Sie den Code zum Erstellen eines NN mithilfe von Chainer.
import chainer
import chainer.functions as F
import chainer.links as L
from chainer import training
class MyChain(chainer.Chain):
def __init__(self, n_input, n_node, n_output):
#Initialisieren Sie das Gewicht mit einer Gaußschen Verteilung und bestimmen Sie die Skala der Standardabweichung mit der Skala
w = chainer.initializers.HeNormal(scale=1.0)
super(MyChain, self).__init__()
#Erstellen Sie eine 4-Schicht-NN
with self.init_scope():
self.l1 = L.Linear(n_input, n_node, initialW=w)
self.l2 = L.Linear(n_node, n_node, initialW=w)
self.l3 = L.Linear(n_node, n_node, initialW=w)
self.l4 = L.Linear(n_node, n_output, initialW=w)
def __call__(self, x):
#Verwenden Sie die Relu-Funktion für die Aktivierungsfunktion
h = F.relu(self.l1(x))
h = F.relu(self.l2(h))
h = F.relu(self.l3(h))
return self.l4(h)
def create_model():
#Erstellen Sie eine NN mit 10 Eingabedimensionen, 200 Knoten und 10 Ausgabedimensionen
model = L.Classifier(MyChain(10, 200, 10), lossfun=F.softmax_cross_entropy)
#Adam wird als Optimierungsfunktion verwendet, Alpha(Lernrate)0.025, & epsi; 1e-Auf 3 setzen.
optimizer = chainer.optimizers.Adam(alpha=0.025, eps=1e-3)
optimizer.setup(model)
return model, optimizer
Das Obige ist der Code zum Erstellen des NN-Modells.
Die Aktivierungsfunktion besteht darin, die Ausdruckskraft des NN-Modells zu erhöhen. Mit anderen Worten, es wird in der Lage sein, komplexere Erkennungsprobleme zu behandeln.
Zu den Aktivierungsfunktionen gehören neben relu auch Tanh, Sigmoid, Swish usw. Sie können auch andere Aktivierungsfunktionen über den offiziellen Referenzlink des Chainers unten sehen (siehe Spalte Aktivierungsfunktionen). https://docs.chainer.org/en/stable/reference/functions.html
Die Verlustfunktion dient zur Berechnung des Fehlers. Normalerweise wird NN in Richtung einer Verlustreduzierung optimiert. Die Verlustfunktion wird auch als Zielfunktion bezeichnet.
Ich habe softmax_cross_entropy für die Verlustfunktion (loss_fun) verwendet, aber es gibt andere Verlustfunktionen im Abschnitt Verlustfunktionen des obigen Links.
Die Optimierungsfunktion bestimmt, wie der NN aktualisiert wird.
Neben Adam gibt es SGD, RMSprop, AdaGrad usw. als Optimierer. Sie können auch andere Aktivierungsfunktionen über den offiziellen Chainer-Referenzlink unten sehen. https://docs.chainer.org/en/stable/reference/optimizers.html (Die Parameter der Optimierungsfunktion hängen stark von der Genauigkeit des Lernens ab. Es ist daher ratsam, verschiedene Kombinationen auszuprobieren, um den optimalen Wert zu finden.)
Unten finden Sie den Code (Vorlage), um mit dem Lernen zu beginnen. Kopieren Sie es und fügen Sie es in dieselbe .py-Datei ein, wie der obige Build-Code für das NN-Modell.
#Nehmen Sie Zugdaten und Testdaten als Argumente
def learn(train, test):
#Eigentum
epoch = 8
batchsize = 256
#NN-Modellerstellung
model, optimizer = create_model()
#Definition des Iterators
train_iter = chainer.iterators.SerialIterator(train, batchsize) #Zum Lernen
test_iter = chainer.iterators.SerialIterator(test, batchsize, repeat=False) #Zur Auswertung
#Updater Registrierung
updater = training.StandardUpdater(train_iter, optimizer)
#Trainerregistrierung
trainer = training.Trainer(updater, (epoch, 'epoch'))
#Lernstatus anzeigen und speichern
trainer.extend(extensions.LogReport()) #Log
trainer.extend(extensions.Evaluator(test_iter, model)) #Anzeige der Epochennummer
trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'elapsed_time'] )) #Anzeige des Berechnungsstatus
#Fang an zu lernen
trainer.run()
#sparen
#chainer.serializers.save_npz("result/Agent" + str(episode) + ".model", model)
Die hier definierte Lernfunktion empfängt Lehrerdaten und Testdaten als Argumente. (Erstellen Sie Lehrerdaten und Testdaten entsprechend dem, was Sie trainieren möchten.) Schleifen Sie diese Funktion auch entsprechend der Anzahl der Episoden.
Abschließend werde ich die Anzahl der Epochen und die Chargengröße erläutern.
Die Epochennummer ist ein Wert, der bestimmt, wie oft dieselben Lehrerdaten trainiert werden. Normalerweise gibt es nur wenige Dinge, die gleichzeitig gelernt werden können. Lassen Sie sie also mehrmals lernen. Wenn Sie es jedoch zu groß einstellen, führt dies zu Überlernen. Passen Sie es daher an, während Sie verschiedene Werte ausprobieren.
Die Stapelgröße ist ein Wert, der bestimmt, wie viele Teile aus den Lehrerdaten entnommen und trainiert werden. Normalerweise ist der Wert umso größer, je größer die Anzahl der Daten ist. Es gibt auch einen Wert, der als Anzahl der Iterationen bezeichnet wird. Sobald jedoch die Stapelgröße und die Anzahl der Iterationen bestimmt sind, wird der andere Wert automatisch bestimmt.
Das Obige ist der Inhalt dieser Zeit. Ich habe es nur kurz als Ganzes erklärt. Wenn Sie mehr darüber erfahren möchten, lesen Sie bitte andere Websites und Artikel.
Ich hoffe, dieser Artikel ist ein guter Einstiegspunkt für alle, die versuchen, tiefes Lernen mit Chainer zu studieren.
Recommended Posts