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.

figure_1.png

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.

Recommended Posts

Tutoriel d'apprentissage en profondeur de la construction d'environnement
[Windows 10] Construction de l'environnement "Deep Learning from scratch"
Apprentissage profond à partir de zéro
Réaliser la construction d'environnement pour "Deep Learning from scratch" avec docker et Vagrant
Apprentissage profond à partir de zéro 1 à 3 chapitres
Deep learning / Deep learning from scratch 2 Chapitre 4 Mémo
Deep learning / Deep learning made from scratch Chapitre 3 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 5 Mémo
Créez un environnement pour "Deep Learning from scratch" avec Docker
Apprentissage profond à partir de zéro (calcul des coûts)
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 7 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 8 Mémo
De Ubuntu 20.04 introduction à la construction d'environnement
Didacticiel "CNTK" de la bibliothèque d'apprentissage en profondeur de Microsoft
Deep learning / Deep learning made from scratch Chapitre 5 Mémo
Deep learning / Deep learning made from scratch Chapitre 4 Mémo
Deep learning / Deep learning from scratch 2 Chapitre 3 Mémo
Mémo d'apprentissage profond créé à partir de zéro
L'apprentissage en profondeur
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 6 Mémo
Mémo d'auto-apprentissage "Deep Learning from scratch" (n ° 15) Tutoriel pour débutants TensorFlow
Apprentissage amélioré pour apprendre de zéro à profond
[Mémo d'apprentissage] Le Deep Learning fait de zéro [Chapitre 7]
Apprentissage profond à partir de zéro (propagation vers l'avant)
Apprentissage profond / Apprentissage profond à partir de zéro 2-Essayez de déplacer GRU
Deep learning / Deep learning made from scratch Chapitre 6 Mémo
[Mémo d'apprentissage] Deep Learning fait de zéro [Chapitre 5]
[Mémo d'apprentissage] Le Deep Learning fait de zéro [Chapitre 6]
Alignement d'image: du SIFT au deep learning
Créer un environnement pour Python et l'apprentissage automatique (macOS)
"Deep Learning from scratch" avec Haskell (inachevé)
Deep learning / Deep learning made from scratch Chapitre 7 Mémo
Enregistrement d'apprentissage de la lecture "Deep Learning from scratch"
Tutoriel de construction d'environnement pour MXNet (partie gluon)
[Deep Learning from scratch] À propos de l'optimisation des hyper paramètres
Apprentissage profond à partir des bases mathématiques (pendant la fréquentation)
[Mémo d'apprentissage] Deep Learning fait de zéro [~ Chapitre 4]
Construction de l'environnement Django
Construction de l'environnement DeepIE3D
Construction de l'environnement Linux
Mémorandum d'apprentissage profond
Construction d'environnement (python)
construction d'environnement django
Construction de l'environnement CodeIgniter
construction d'environnement python
Apprentissage en profondeur Python
Python - Construction de l'environnement
Apprentissage profond × Python
Construction de l'environnement Golang
Créez un environnement d'apprentissage pour le «Deep learning from scratch» avec Cloud9 (jupyter miniconda python3)
Construction de l'environnement de word2vec
Mémo d'auto-apprentissage "Deep Learning from scratch" (glossaire illisible)
Collecter des informations depuis Twitter avec Python (construction de l'environnement)
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 9) Classe MultiLayerNet
De la création de l'environnement Kivy à l'affichage de Hello World
Deep Learning from scratch ① Chapitre 6 "Techniques liées à l'apprentissage"
GitHub du bon livre "Deep Learning from scratch"
Construction d'environnement explosif Python à partir de zéro (Mac)