[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()

20170104_001.png

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())

20170104_002.png (Omis) 20170104_003.png

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

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.

Recommended Posts

Introduction à Private Chainer
Introduction à Private TensorFlow
Introduction à MQTT (Introduction)
Introduction à Scrapy (3)
Premiers pas avec Supervisor
Introduction à Tkinter 1: Introduction
Introduction à PyQt
Introduction à Scrapy (2)
[Linux] Introduction à Linux
Introduction à Scrapy (4)
Introduction à discord.py (2)
Introduction à Lightning Pytorch
Premiers pas avec le Web Scraping
Introduction aux baies non paramétriques
Introduction à EV3 / MicroPython
Introduction au langage Python
Introduction à la reconnaissance d'image TensorFlow
Introduction à OpenCV (python) - (2)
Introduction à PyQt4 Partie 1
Introduction à l'injection de dépendances
Introduction à l'apprentissage automatique
AOJ Introduction à la programmation Sujet 1, Sujet 2, Sujet 3, Sujet 4
Introduction au module de papier électronique
Introduction à la méthode Monte Carlo
[Mémorandum d'apprentissage] Introduction à vim
Introduction à PyTorch (1) Différenciation automatique
opencv-python Introduction au traitement d'image
Introduction à Python Django (2) Win
Introduction à l'écriture de Cython [Notes]
Une introduction à l'apprentissage automatique
[Introduction à cx_Oracle] Présentation de cx_Oracle
Une super introduction à Linux
AOJ Introduction à la programmation Sujet n ° 7, Sujet n ° 8
Transition de Chainer v1 à Chainer v2
Introduction à RDB avec sqlalchemy Ⅰ
[Introduction au système] Retracement de Fibonacci ♬
Introduction à l'optimisation non linéaire (I)
Introduction à la communication série [Python]
AOJ Introduction à la programmation Sujet n ° 5, Sujet n ° 6
Introduction au Deep Learning ~ Règles d'apprentissage ~
[Introduction à Python] <liste> [modifier le 22/02/2020]
Introduction à Python (version Python APG4b)
Une introduction à la programmation Python
[Introduction à cx_Oracle] (8e) version de cx_Oracle 8.0
Introduction à discord.py (3) Utilisation de la voix
Introduction à l'optimisation bayésienne
Apprentissage par renforcement profond 1 Introduction au renforcement de l'apprentissage
Super introduction à l'apprentissage automatique
Introduction à Ansible Part «Inventaire»
Série: Introduction à cx_Oracle Contents
[Introduction] Comment utiliser open3d
Introduction à Python pour, pendant
Introduction au Deep Learning ~ Rétropropagation ~
Introduction à Ansible Part ④'Variable '
Introduction à la commande vi (Remarque)
[Présentation de l'application Udemy Python3 +] 58. Lambda