[PYTHON] Tutoriel d'apprentissage en profondeur de la construction d'environnement

L'apprentissage profond est devenu un sujet brûlant ces jours-ci,

"Je veux étudier, mais je ne suis pas sûr de ce que je peux faire en premier lieu ..."

Pour ces personnes, nous présenterons la méthode de la construction de l'environnement à l'exécution du deep learning sur Mac.

construction d'environnement python

En parlant d'apprentissage automatique et d'apprentissage en profondeur, il s'agit de python. Pour le moment, préparez la construction de l'environnement python. Tout d'abord, installons python. Ouvrons un terminal et exécutons-le dans l'ordre.

Terminal

brew install pyenv
pyenv install anaconda3-4.0.0

Ceci termine l'installation.

Terminal

pyenv versions

Et courir

* system (set by ~~~)
  anaconda3-4.0.0

Si anaconda3-4.0.0 apparaît comme ceci, l'installation est réussie.

Ensuite, passez le chemin de pyenv.

Terminal

echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bash_profile
echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bash_profile
echo 'eval "$(pyenv init -)"' >> ~/.bash_profile
source ~/.bash_profile

C'est acceptable!

Ensuite, passons à la version python que nous avons ajoutée précédemment.

Terminal

pyenv grobal anaconda3-4.0.0

Vous devriez avoir réussi à changer.

Terminal

python

En tapant dans le terminal et en exécutant

Python 3.5.2 |Continuum Analytics, Inc.| (default, Jul  2 2016, 17:52:12)

Si Python 3.x.x etc. est affiché, le basculement est réussi.

installation et paramètres de keras

Ensuite, installons Keras, qui est célèbre pour son cadre d'apprentissage en profondeur. Si vous essayez de créer un apprentissage profond à partir de zéro, cela demandera beaucoup d'efforts, mais avec keras, vous pouvez le faire en 10 lignes.

De plus, j'inclurai également une bibliothèque qui gère le format h5 pour sauvegarder les résultats d'apprentissage de keras.

pip install h5py
pip install keras

L'installation est terminée. Après cela, effectuez quelques réglages.

Terminal

mkdir ~/.keras
echo '{"epsilon": 1e-07, "floatx": "float32", "backend": "theano"}' >> ~/.keras/keras.json

[Astuces] Qu'est-ce que le backend?

Vous pouvez le sauter et le lire du tout.

À propos, à la base des algorithmes d'apprentissage profond, il est nécessaire d'effectuer des calculs mathématiques. En fait, la bibliothèque qui effectue ce calcul mathématique est appelée backend, et elle est portée par une bibliothèque différente de keras. Vous pouvez choisir entre theano ou tensorflow, et theano sera installé en même temps que vous installez keras.

Exécution du Deep Learning

Pardon de te faire attendre. Faisons immédiatement du deep learning.

keras_tutorial.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy as np
import keras

from keras.utils import np_utils
from keras.datasets import mnist
from keras.layers.convolutional import Convolution2D, MaxPooling2D
from keras.layers.core import Activation, Dense, Dropout, Flatten

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(-1, 28, 28, 1).astype('float32')/255
x_test = x_test.reshape(-1, 28, 28, 1).astype('float32')/255
y_train = np_utils.to_categorical(y_train, 10)
y_test = np_utils.to_categorical(y_test, 10)

model = keras.models.Sequential()
model.add(Convolution2D(nb_filter=20, nb_row=5, nb_col=5,
                        border_mode='valid',
                        input_shape=(28, 28, 1)))
model.add(Activation("relu"))
model.add(Convolution2D(nb_filter=15, nb_row=5, nb_col=5))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.5))
model.add(Flatten())
model.add(Dense(128))
model.add(Activation("relu"))
model.add(Dropout(0.5))
model.add(Dense(10))
model.add(Activation("softmax"))
model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=['accuracy'])

model.fit(x_train, y_train,  batch_size=100, nb_epoch=3, verbose=1)

score = model.evaluate(x_test, y_test, show_accuracy=True, verbose=0)

print("test-accuracy: {}".format(score[1]))

model_json_str = model.to_json()
open('model.json', 'w').write(model_json_str)
model.save_weights('weights.h5')

Si l'écran suivant apparaît, l'apprentissage en profondeur peut être démarré en toute sécurité.

Using Theano backend.
Epoch 1/3
 5100/60000 [=>............................] - ETA: 111s - loss: 1.2484 - acc: 0.5733

Vérifiez les résultats de l'apprentissage en profondeur

Eh bien, l'apprentissage est-il terminé? Une fois terminé, vous devriez voir quelque chose comme ceci:

test-accuracy: 0.989

Cela signifie qu'il y a 98,9% de chances que les nombres puissent être identifiés par rapport à des données (données de test) qui sont complètement différentes de l'entraînement.

Maintenant que vous ne savez pas quels personnages sont jugés, exécutons le script suivant.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy as np
import pylab
import keras

from keras.utils import np_utils
from keras.datasets import mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_test = x_test.reshape(-1, 28, 28, 1).astype('float32')/255

model = keras.models.model_from_json(open('model.json').read())
model.load_weights('weights.h5')
model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=['accuracy'])

tests = x_test[:20]
labels = model.predict(tests, verbose=1)

for index, (image, label) in enumerate(zip(tests, labels)):
    pylab.subplot(4, 5, index + 1)
    pylab.axis('off')
    pylab.imshow(image.reshape(28, 28), cmap=pylab.cm.gray_r, interpolation='nearest')
    pylab.title(np.argmax(label))
pylab.show()

Ici, le résultat d'apprentissage précédent est enregistré dans model.json et weights.h5, il est donc rechargé.

Je pense que les résultats sont les suivants. Il montre quel numéro a été jugé pour chaque numéro.

introduction

Qu'as-tu pensé.

Quoi qu'il en soit, j'ai posté le script pour ceux qui veulent quand même l'exécuter.

Je serais très heureux si plus de gens s'y intéressaient et commençaient à étudier l'apprentissage profond.

Enfin, j'aimerais vous présenter le livre d'introduction.

[・ Deep Learning from scratch La théorie et la mise en œuvre de l'apprentissage profond appris avec Python](https://www.amazon.co.jp/%E3%82%BC%E3%83%AD%E3%81%8B%E3 % 82% 89% E4% BD% 9C% E3% 82% 8B Apprentissage profond-Python% E3% 81% A7% E5% AD% A6% E3% 81% B6% E3% 83% 87% E3% 82% A3 % E3% 83% BC% E3% 83% 97% E3% 83% A9% E3% 83% BC% E3% 83% 8B% E3% 83% B3% E3% 82% B0% E3% 81% AE% E7 % 90% 86% E8% AB% 96% E3% 81% A8% E5% AE% 9F% E8% A3% 85-% E6% 96% 8E% E8% 97% A4-% E5% BA% B7% E6 % AF% 85 / dp / 4873117585 / ref = pd_bxgy_14_2? _ Encodage = UTF8 & psc = 1 & refRID = 6D052QXCKJEGZ5ZY4HRV)

Il s'agit d'un livre d'introduction sous forme de compréhension de la théorie avec une implémentation en python. Il est recommandé à ceux qui veulent comprendre tout en programmant.

・ Apprentissage en profondeur

Il n'y a pas de mise en œuvre et le contenu principal est la théorie, mais il est expliqué d'une manière assez facile à comprendre même dans le livre où la théorie est écrite. La caractéristique est qu'il couvre un large éventail de contenus de base aux méthodes topiques.