Eines der beliebtesten Wörter von 2015 bis 2016 ist "künstliche Intelligenz", aber es ist nicht so, dass Sie sagen "Ich kann es nicht verwenden, weil ich es nicht gut kenne", also studieren Sie Chainer unabhängig von der Arbeit. Ich werde anfangen.

Früher habe ich SVM oder RandomForest in Szenen verwendet, in denen ein Diskriminator für das Geschäft benötigt wird, aber von nun an kann ich einige Fragen erwarten, die beim Schreiben eines Diskriminators mit SVM wie gewohnt gestellt werden (" Was passiert, wenn ich Deep Learning mache? “→„ Ich möchte nichts tun “), ich möchte meine sensible Einstellung zu populären Wörtern (Mysterium) betonen.

Verweise:

Chainer – A flexible framework of neural networks

Chainer installieren

Wenn Sie das Lesen von http://docs.chainer.org/en/stable/install.html nicht verstehen, ist die Installation so einfach, dass Sie es sofort verlassen müssen.

Derzeit ist CUDA keine Umgebung, die auf meinem Mac zu Hause verwendet werden kann. Daher werde ich versuchen, Chainer ohne CUDA-Unterstützung zu installieren.

Was ist mit der Unterstützung bei anaconda?

Zuvor wurde die Python-Umgebung für meinen Mac zu Hause mit Anaconda erstellt. Überprüfen Sie daher zunächst, ob sie mit conda installiert werden kann.

% anaconda search -t conda chainer
Using Anaconda API: https://api.anaconda.org
Run 'anaconda show <USER/PACKAGE>' to get more details:
Packages:
     Name                      |  Version | Package Types   | Platforms
     ------------------------- |   ------ | --------------- | ---------------
     steerapi/chainer          |        0 | conda           | win-64
                                          : A flexible framework of neural networks
Found 1 packages

Es scheint, dass nur das Win-64-Paket vorbereitet ist. Installieren Sie daher Chainer mit Pip gemäß Dokumentation.

% pip install chainer
(Unterlassung)
Installing collected packages: chainer
Successfully installed chainer-1.19.0

Zu diesem Zeitpunkt habe ich keinen Fehler erhalten, als ich "Import Chainer" auf Ipython ausprobiert habe, daher denke ich, dass es wahrscheinlich in Ordnung ist.

Ein Tutorial durchführen

Führen Sie nach der Installation [Tutorial] aus (http://docs.chainer.org/en/stable/tutorial/index.html). Dies ist wichtig, um zu wissen, was getan werden kann, und um zu wissen, nach welchen Schlüsselwörtern ich beim Lesen eines Dokuments suchen soll, um das zu erreichen, was ich tun möchte.

Ich habe hier verstanden, dass Sie die technischen Begriffe neuronaler Netze verstehen müssen, zumindest genug, um die englische Dokumentation zu lesen. Es ist schwierig, dieses Tutorial überhaupt zu lesen, wenn Sie sich das gerichtete Diagramm und die Gewichtung der Kombination von ○ und → auf Japanisch vage vorstellen können (das bin ich).

Nun, aber das Schlüsselwort lautet "Define-by-Run".

Vor dem Durchführen des Tutorials

In dem im Lernprogramm eingeführten Code wird Folgendes weggelassen.

import numpy as np
import chainer
from chainer import cuda, Function, gradient_check, report, training, utils, Variable
from chainer import datasets, iterators, optimizers, serializers
from chainer import Link, Chain, ChainList
import chainer.functions as F
import chainer.links as L
from chainer.training import extensions

Ich verwende CUDA nicht in der tatsächlichen Mac-Umgebung zu Hause, daher denke ich, dass es notwendig ist, dies abzuziehen.

MNIST Das Tutorial führt auch in die Implementierung von MNIST ein. Bereiten Sie zuerst die Daten vor.

train, test = datasets.get_mnist()

Wenn dies ausgeführt wird, werden die handschriftlichen Zeichendaten des in MNIST verwendeten Beispiels heruntergeladen, wie in der Abbildung gezeigt.

% ls -A ~/.chainer/dataset/pfnet/chainer/mnist/
test.npz   train.npz

Der Trainingsdatensatz wird nach jedem Versuch gemischt, der Testdatensatz muss jedoch nicht gemischt werden. Daher wird angegeben, dass er wie folgt festgelegt werden soll. Dies bedeutet, dass Sie die Optionen ändern müssen, die Sie Iteratoren zum Trainieren und Testen von Datensätzen geben.

train_iter = iterators.SerialIterator(train, batch_size=100, shuffle=True)
test_iter = iterators.SerialIterator(test, batch_size=100, repeat=False, shuffle=False)

Nachdem das Dataset fertig ist, befolgen Sie das Lernprogramm, um eine dreistufige Netzwerkstruktur zu definieren.

class MLP(Chain):
    def __init__(self, n_units, n_out):
        super(MLP, self).__init__(
            l1 = L.Linear(None, n_units),
            l2 = L.Linear(None, n_units),
            l3 = L.Linear(None, n_out)
        )
    
    def __call__(self, x):
        h1 = F.relu(self.l1(x))
        h2 = F.relu(self.l2(h1))
        y = self.l3(h2)
        return y

Es ist ein Chainer, weil l1, l2 und l3 in einer Kette aufgerufen werden. Jedes von l1, l2 und l3 sieht aus wie eine Funktion, die einen Ein- und Ausgang hat, aber dies wird im Kettensystem als Glied bezeichnet, und der Zweck dieses Systems besteht darin, diesen Eingang zu optimieren. Ist es wie zu werden?

In einem solchen neuronalen Netz eines dreischichtigen Netzwerks wird die zweite Schicht normalerweise als verborgene Schicht behandelt, aber insbesondere bei der Definition dieser Netzwerkstruktur wird nicht eindeutig erklärt, dass l2 eine verborgene Schicht ist. Wenn jedoch \ call fertig ist, wird h1 aus der Eingabe x mit l1 berechnet, und h1 wird ohne Ausgabe in l2 eingegeben, und das resultierende h2 wird auch ohne Ausgabe ausgegeben. Ist es richtig zu verstehen, dass die Verknüpfung l2 als Ergebnis auf die verborgene Schicht zeigt, da sie eine Struktur hat, in der nur y des Berechnungsergebnisses ausgegeben wird?

Dies bedeutet, dass es beim Erweitern der Klasse MLP von 3 Schichten auf 4 Schichten und 5 Schichten gut erscheint, nur eine Zwischenschicht hinzuzufügen, wenn \ __ init__.

Die Funktion, die die Genauigkeit und den Verlust dieses Netzwerks bewertet, ist als `` `chainer.links.Classifier``` definiert, daher nennen wir es Sole.

model = L.Classifier(MLP(100, 10))
optimizer = optimizers.SGD()
optimizer.setup(model)

Die plötzlich erscheinende SGD () ist [Probabilistic Gradient Descent Method](https://ja.wikipedia.org/wiki/%E7%A2%BA%E7%8E%87%E7%9A % 84% E5% 8B% BE% E9% 85% 8D% E9% 99% 8D% E4% B8% 8B% E6% B3% 95).

An diesem Punkt ist es endlich möglich, mit dem Lernset zu trainieren.

updater = training.StandardUpdater(train_iter, optimizer)
trainer = training.Trainer(updater, (20, 'epoch'), out='result')

Um zu lernen, können Sie run () des Trainers aufrufen, aber ich möchte den Lernstatus kennen (oder besser gesagt, ich möchte sehen, wo das Python-Skript, das ich bisher geschrieben habe, ordnungsgemäß funktioniert. ) In diesem Fall sollten Sie anscheinend die Erweiterung festlegen.

trainer.extend(extensions.Evaluator(test_iter, model))
trainer.extend(extensions.LogReport())
trainer.extend(extensions.PrintReport(['epoch', 'main/accuracy', 'validation/main/accuracy']))
trainer.extend(extensions.ProgressBar())

(Weggelassen)

Nach 20-maligem wiederholten Lernen wurde ein Klassifikator erstellt. Für Details speichert der Ergebnisordner das laufende Protokoll in einer Textdatei namens log (weil ich extensions.LogReport angegeben und out = 'result' für Trainer angegeben habe).

Zusammenfassung

Zusammenfassung bisher.

Ein Stapel namens Link, der Ein- und Ausgänge empfängt (Funktion? Klasse?)
Link kann so geschrieben werden, dass er in einer Kettenreaktion aufgerufen wird
Der vom Eingang zu Link1 empfangene Ausgang wird zum Eingang zu Link2.
Die Ausgabe von Link2 wird zur Eingabe von Link3 ――Was war "Define-by-Run"? ――Es ist schwer zu verstehen, wenn Sie es nicht mit einer anderen Implementierung eines neuronalen Netzes in der Vergangenheit vergleichen.

Nach dem Eindruck, den ich bisher gesehen habe, muss ich etwas mehr über neuronale Netze wissen, aber es gibt keine Anforderung für "komplexes Schreiben, das stark von der Bibliothek abhängt", aber es ist ein sehr pythonartiges Schreiben und Denken. Es stellte sich heraus, dass ich das Gefühl hatte, cool zu sein. Ich verstehe, das ist ein beliebter Grund.

Übrigens habe ich unter http://qiita.com/fukuit/items/d69d8ca1ad558c4de014 versucht, die Nummer mit dem k-ten nächsten Nachbarn zu bestimmen, der an OpenCV angeschlossen ist, aber wie ist das Ergebnis im Vergleich zu Sole? Mit anderen Worten, es scheint, dass die Genauigkeit in 20 Versuchen etwa 0,95 beträgt, so dass gesagt werden kann, dass die Leistung als Diskriminator besser ist als KNN, die etwa 0,91 betrug.

Der heutige Code

Das Tutorial ist bis zu diesem Punkt.

https://github.com/fukuit/Python_SelfLearning/blob/master/chainer_lesson/mnist_train.py