[PYTHON] Introduction à Private Chainer
L'un des mots populaires de 2015 à 2016 est «intelligence artificielle», mais ce n'est pas le cas que vous disiez «je ne peux pas l'utiliser parce que je ne le connais pas bien», donc étudier Chainer quel que soit le travail. Je vais commencer.
J'utilisais SVM ou RandomForest dans des scènes où un discriminateur est nécessaire pour les affaires, mais à partir de maintenant, je peux m'attendre à des questions qui seront posées lors de l'écriture d'un discriminateur avec SVM comme d'habitude (" Que se passe-t-il si je fais du Deep Learning? »→« Je ne veux rien faire »), je veux souligner mon attitude sensible aux mots populaires (mystère).
Les références:
Installer le chainer
Si vous ne comprenez pas en lisant http://docs.chainer.org/en/stable/install.html, c'est tellement facile à installer qu'il faut le laisser sur place.
Pour le moment, CUDA n'est pas un environnement qui peut être utilisé sur mon Mac à la maison, je vais donc essayer d'installer le chainer sans le support CUDA.
Qu'en est-il du support chez anaconda?
Avant cela, l'environnement Python de mon Mac domestique est construit avec Anaconda, alors vérifiez d'abord s'il peut être installé avec conda.
% 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
Il semble que seul le paquet win-64 soit préparé, donc installez chainer avec pip selon Documentation.
% pip install chainer
(Omission)
Installing collected packages: chainer
Successfully installed chainer-1.19.0
À ce stade, je n'ai pas eu d'erreur lorsque j'ai essayé import chainer sur ipython, donc je pense que c'est probablement OK.
Réalisation d'un tutoriel
Après l'installation, exécutez le Tutoriel. Ceci est important pour savoir "ce qui peut être fait?" Et aussi pour indiquer "quels mots clés dois-je rechercher lors de la lecture d'un document pour réaliser ce que je veux faire?"
Donc, ce que j'en suis venu à comprendre ici, c'est que vous devez comprendre les termes techniques des réseaux neuronaux, au moins suffisamment pour lire la documentation en anglais. Il est difficile de lire ce tutoriel en premier lieu si vous pouvez imaginer vaguement le graphe orienté et la pondération de la combinaison de ○ et → en japonais (c'est moi).
Eh bien, mais le mot-clé est "Define-by-Run".
Avant de mener le tutoriel
Dans le code présenté dans le didacticiel, ce qui suit est omis.
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
Je n'utilise pas CUDA dans l'environnement Mac à la maison, donc je pense qu'il est nécessaire de le déduire.
MNIST Le didacticiel présente également l'implémentation de MNIST. Préparez d'abord les données.
train, test = datasets.get_mnist()
Lorsque ceci est exécuté, les données de caractères manuscrites de l'exemple utilisé dans MNIST seront téléchargées comme indiqué sur la figure.
% ls -A ~/.chainer/dataset/pfnet/chainer/mnist/
test.npz train.npz
L'ensemble de données d'entraînement sera mélangé après chaque essai, mais l'ensemble de données de test n'aura pas besoin d'être mélangé, il est donc conseillé de le définir comme suit. Cela signifie que vous devez modifier les options que vous donnez aux itérateurs pour la formation et le test des ensembles de données.
train_iter = iterators.SerialIterator(train, batch_size=100, shuffle=True)
test_iter = iterators.SerialIterator(test, batch_size=100, repeat=False, shuffle=False)
Maintenant que le jeu de données est prêt, suivez le didacticiel pour définir une structure de réseau à trois niveaux.
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
C'est un chainer parce que l1, l2 et l3 sont appelés dans une chaîne. Chacune de l1, l2 et l3 ressemble à une fonction qui a une entrée et des sorties, mais cela s'appelle un lien dans le système de chaînage, et le but de ce système est d'optimiser cette entrée. Est-ce comme devenir?
Ainsi, dans un tel réseau de neurones d'un réseau à trois couches, la deuxième couche est généralement traitée comme une couche cachée, mais surtout dans la définition de cette structure de réseau, il n'est pas clairement déclaré que l2 est une couche cachée. Cependant, lorsque \ call est fait, h1 est calculé à partir de l'entrée x avec l1, et que h1 est entré dans l2 sans être sorti en particulier, et le h2 résultant est également sorti sans sortie particulière. Puisqu'il a une structure dans laquelle seul y du résultat du calcul est sorti, est-il correct de comprendre que le lien l2 pointe vers la couche cachée en conséquence?
Cela signifie que lorsque vous étendez la classe MLP de 3 couches à 4 couches et 5 couches, il semble bon d'ajouter simplement une couche intermédiaire lorsque \ init.
La fonction qui évalue la précision et la perte de ce réseau est définie comme `` chainer.links.Classifier '', donc nous l'appelons Sole.
model = L.Classifier(MLP(100, 10))
optimizer = optimizers.SGD()
optimizer.setup(model)
Ce SGD soudain () est [méthode de descente de gradient probabiliste](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).
À ce stade, il est enfin possible de s'entraîner à l'aide de l'ensemble d'apprentissage.
updater = training.StandardUpdater(train_iter, optimizer)
trainer = training.Trainer(updater, (20, 'epoch'), out='result')
Maintenant, pour apprendre, vous pouvez appeler run () de trainer, mais je veux connaître l'état de l'apprentissage (ou plutôt, je veux voir où le script python que j'ai écrit jusqu'à présent fonctionne correctement. ) Dans ce cas, il semble que vous deviez définir l'extension.
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())
(Omis)
Ainsi, après 20 fois d'apprentissage répété, un classificateur a été créé. Pour plus de détails, le dossier de résultats stocke le journal en cours d'exécution dans un fichier texte appelé log (car j'ai spécifié extensions.LogReport et spécifié out = 'result' pour Trainer).
Résumé
Résumé à ce jour.
--Un lot appelé Link qui reçoit des entrées et des sorties (fonction? Classe?) --Le lien peut être écrit pour être appelé dans une réaction en chaîne
- La sortie reçue de l'entrée vers link1 devient l'entrée vers link2.
- La sortie de link2 devient l'entrée de link3 ―― Qu'est-ce que «Define-by-Run»? ――Je ne sais pas à moins de le comparer à une autre implémentation de réseau neuronal dans le passé.
D'après l'impression que j'ai vue jusqu'à présent, je dois avoir un peu plus de connaissances sur les réseaux de neurones, mais il n'y a aucune exigence pour "une écriture complexe qui dépend fortement de la bibliothèque", mais c'est une écriture et une réflexion très python. Il s'est avéré que cela me donnait l'impression que c'était cool. Je vois, c'est une raison populaire.
En passant, sur http://qiita.com/fukuit/items/d69d8ca1ad558c4de014, j'ai essayé de déterminer le nombre avec le k-ième voisin le plus proche attaché à OpenCV, mais comment le résultat est-il comparé à Sole? En d'autres termes, il semble que la précision est d'environ 0,95 dans 20 essais, donc on peut dire que la performance en tant que discriminateur est meilleure que KNN qui était d'environ 0,91.
Code du jour
Le tutoriel est à ce point.
- https://github.com/fukuit/Python_SelfLearning/blob/master/chainer_lesson/mnist_train.py
Recommended Posts