Es hat sich ziemlich verändert, seit Chainer 1.11.0 wurde, also werde ich mein eigenes Verständnis schreiben. So viel wie möglich werde ich es für diejenigen verständlich machen, die Python und Chainer noch nicht kennen.
Der Code lautet hier Es ist eine Datei namens train_mnist.py im Beispiel.
MNIST mnist ist ein Datensatz von Bildern mit einer Größe von 28 x 28. Es wird häufig als Einführung in das maschinelle Lernen verwendet.
class MLP(chainer.Chain):
def __init__(self, n_in, n_units, n_out):
super(MLP, self).__init__(
l1=L.Linear(n_in, n_units),
l2=L.Linear(n_units, n_units),
l3=L.Linear(n_units, n_out),
)
def __call__(self, x):
h1 = F.relu(self.l1(x))
h2 = F.relu(self.l2(h1))
return self.l3(h2)
In der Netzwerkdefinition definiert \ _ \ _ init \ _ \ _ die zu verwendende Schicht. Diesmal,
\ _ \ _ Call \ _ \ _ beschreibt ein bestimmtes Netzwerk. Dieses Mal verwenden wir eine Aktivierungsfunktion namens relu für die Ausgabe von l1 und l2.
Parser Vorerst Parser
parser = argparse.ArgumentParser(description='Chainer example: MNIST')
parser.add_argument('--batchsize', '-b', type=int, default=100,
help='Number of images in each mini-batch')
parser.add_argument('--epoch', '-e', type=int, default=20,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out', '-o', default='result',
help='Directory to output the result')
parser.add_argument('--resume', '-r', default='',
help='Resume the training from snapshot')
parser.add_argument('--unit', '-u', type=int, default=1000,
help='Number of units')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# unit: {}'.format(args.unit))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
Parser ist ein praktischer Typ, der es einfacher macht, Parameter festzulegen, wenn Python mit Befehlen ausgeführt wird. Zum Beispiel, wenn Sie im Terminal Folgendes ausführen
> $ python train_mnist.py -g 0 -u 100
GPU: 0
# unit: 100
# Minibatch-size: 100
# epoch: 20
Es wird angezeigt. Wenn keine Epoche angegeben ist, ist dies der von default initialisierte Wert. Wenn Sie es selbst hinzufügen möchten
add_argument('Name, um später anzurufen', '-Wie im Terminal angeben',Wenn es sich um eine Zahl handelt, geben Sie ein=int,Standardwert, falls nicht angegeben)
Es kann in Form von verwendet werden.
In Chainer werden Zugdaten und Testdaten aufbereitet.
train, test = chainer.datasets.get_mnist()
Es ruft nur die von mnist verwendeten Daten ab und setzt sie in Zug und Test. Welche Art von Form sich in einer Linie befindet (Zug [0]) [[.234809284, .324039284, .34809382 …. .04843098], 3] Der Eingabewert links und die Antwort (Beschriftungswert) rechts sind als Satz enthalten. Mit Chainer lernen Sie außerdem mit dem Zug, versuchen es mit einem Test und sehen die richtige Antwortrate.
Früher habe ich mich auf mich selbst vorbereitet und es viele Male gedreht, um zu lernen, aber ab 1.11.0 habe ich gesagt, dass ich dies verwenden werde, indem ich Daten wie train oben setze. Sie müssen nicht minutenlang schreiben.
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test, args.batchsize,
repeat=False, shuffle=False)
Es scheint, dass alles in Ordnung ist. Es gibt ein Gefühl von Magie
Trainer Ein Trainer wurde hinzugefügt, und es scheint, dass er verschiedene Dinge fast willkürlich tun wird. Bitte geben Sie Ihrem Kind eine Sammlung von Fragen und Antworten an den Tutor. Typisch Das Bild, die Lehre des Studiums einem Tutor zu überlassen (ich weiß nicht, ob es passt)
Stellen Sie zuerst den Trainer ein.
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'),
Lassen Sie diesen optimizer (Lernmethode) mit diesem train_iter (Problem-Sammlung) optimieren, Drehen Sie es _epoch _ (wie viele Runden).
Einige der folgenden Punkte sind nicht immer erforderlich:
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
#Das ist. Prüfung_Ich benutze iter, um jede Epoche zu bewerten (glaube ich)
trainer.extend(extensions.dump_graph('main/loss'))
#Speichern Sie die Netzwerkform im Punktformat, damit sie als Grafik angezeigt werden kann.
trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
#Speichern Sie die Trainerinformationen für jede Epoche. Sie können es lesen und von der Mitte aus neu starten. Hat es das viel schneller gemacht?
trainer.extend(extensions.LogReport())
#Ausgabeprotokoll für jede Epoche
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy']))
#Geben Sie die Informationen an, die per Protokoll ausgegeben werden sollen.
trainer.extend(extensions.ProgressBar())
#Es wird Ihnen sagen, wie weit Sie jetzt und für jede Epoche gehen.
trainer.run()
#Nachdem Sie verschiedene Trainer eingestellt haben, tun Sie dies und führen Sie es tatsächlich aus. Dies ist obligatorisch
main / loss ist die Größe des Unterschieds zur Antwort. mian / Genauigkeit ist die richtige Antwortrate. Ich bin mir nicht sicher, worauf sich Validierung / Haupt / Genauigkeit bezieht. (Wenn jemand einen Kommentar abgeben kann ...)
Ich denke, ich werde es hier erklären und dort nicht erklären, aber das liegt daran, dass ich es noch nicht verstehe.
Ich habe immer noch vor, die Details darüber zu erläutern, wie ich tatsächlich damit gespielt habe.