introduction

Cet article s'adresse aux personnes qui veulent essayer le deep learning, qui est devenu populaire ces dernières années, sans connaître la théorie, ou qui veulent simplement l'utiliser. Je l'ai écrit pour mon propre mémo, veuillez donc signaler toute partie ou erreur déroutante. Keras est un wrapper Python pour Tensorflow et Theano, une bibliothèque d'apprentissage en profondeur. En utilisant cette bibliothèque, vous pouvez expérimenter l'apprentissage en profondeur très facilement et vous pouvez coder de nombreuses structures de réseau sans être conscient des théories difficiles. Dans cet article, nous présenterons Tensorflow et Keras et commencerons par identifier les carrés avec un perceptron multicouche.

(Ajout) Puisqu'il semble que beaucoup de gens l'aient vu, nous avons également ajouté l'identification en lisant les paramètres appris. J'espère que cela sera utile à tout le monde.

(Ajouté le 2017/03/09) TensorFlow 1.0 a été publié par Google le 15 février 2017. Parallèlement à cela, un nouveau module tf.keras sera introduit dans TensorFlow. (Pour l'instant, il semble qu'il sera ajouté dans TensorFlow 1.2.) Par conséquent, vous pourrez utiliser l'API Keras directement à partir de TensorFlow sans avoir à exécuter TensorFlow sur le backend en utilisant Keras comme auparavant. Je me demande où écrire le prochain article, mais je pense probablement à écrire cette série en pure Keras. Si TensorFlow prend également en charge Keras, je pense qu'il sera téléchargé sur Gist en se référant au code de TensorFlow.

Environnement d'exécution

Windows 10（64bit）with only CPU
Python 3.5.2
Anaconda 4.2.0（64bit）
Tensorflow 0.12.1
Keras 1.2.1

Procédure d'installation de l'environnement d'exécution

Installation d'Anaconda

J'utilise Anaconda comme environnement d'exécution pour python sur Windows. Si vous disposez déjà d'un environnement dans lequel vous l'utilisez, vous pouvez l'ignorer. Pour installer Anaconda, accédez à la page de téléchargement officielle (http://www.continuum.io/downloads#windows) et téléchargez le programme d'installation de votre environnement. Après cela, exécutez le programme d'installation et cliquez sur Suivant pour terminer. Parallèlement à l'installation d'Anaconda, les éditeurs appelés Python (Python3 dans mon cas) et le notebook jupyter sélectionnés au moment du téléchargement sont également inclus, il n'est donc pas nécessaire d'installer python séparément.

Installez Tensorflow

Dans Keras, vous pouvez sélectionner la bibliothèque à exécuter sur le backend avec Tensorflow ou Theano, mais ici nous utiliserons Tensorflow. Puisque pip est utilisé pour l'installation, recherchez d'abord Anaconda à partir de l'écran de démarrage et démarrez-le. Immédiatement après l'installation, mettez à jour pip vers la dernière version au cas où. Pour obtenir la dernière version, exécutez la commande suivante dans Anaconda Prompt.

`pip_upgrade`


$ pip install --upgrade pip

Une fois que vous avez la dernière version, installez Tensorflow. Avec l'invite Anaconda ouverte, exécutez la commande suivante: Veuillez noter que les commandes d'installation sont différentes pour les PC équipés de GPU et les PC uniquement CPU.

`tensorflow_install`


#Pour CPU uniquement
$ pip install tensorflow
#Lorsqu'il est équipé d'un GPU
$ pip install tensorflow-gpu

#Comment vérifier s'il est installé
#Exécutez la commande suivante, et si tensorflow est dans la liste, c'est OK.
$ pip list |grep tensorflow

(Ajout) (À compter du 8 mars 2017) Tensorflow ne peut pas être installé avec la commande ci-dessus à moins que la version Python soit 3.5.x. J'ai écrit un article qui résume comment éviter cela, donc si vous ne pouvez pas l'installer, veuillez installer Tensorflow en y faisant référence. Voici l'article. Comment installer le framework d'apprentissage en profondeur Tensorflow 1.0 dans l'environnement Anaconda de Windows

Installation de Keras

Ensuite, exécutez la commande suivante pour terminer l'installation de Keras.

`Keras_install`


#Installation de Keras
$ pip install keras

#Vérifiez s'il est installé
#De même, si vous pouvez confirmer Keras, c'est OK.
$ pip list |grep Keras

Vérifiez s'il peut être installé

Avant d'entrer dans le sujet principal, vérifions si l'installation est correcte. Je pense que l'invite Anaconda est ouverte, alors démarrez python là-bas et vérifiez s'il peut être importé correctement. Ce n'est pas grave si cela ressemble à ceci:

`introduction_confirmation`


#Démarrer python
$ python
#Importer tensorflow
>>> import tensorflow 
#Importation Keras
>>> import keras
using TensorFlow backend

Classification multi-valeurs à l'aide du perceptron multicouche (MLP)

Classification du paysage ou portrait quadrangulaire

Téléchargement de l'ensemble de données

Faisons une classification simple en saisissant l'image suivante. Tout d'abord, les données sont nécessaires pour Deeplearning, veuillez donc les télécharger depuis Site .. Cet ensemble de données est un ensemble de données d'images carrées comme indiqué ci-dessous. Donc, comme point de départ, utilisons Keras pour classer en deux classes, portrait et paysage.

la programmation

Pour savoir comment utiliser Jupyter, veuillez consulter ici pour une compréhension facile. Maintenant, à propos de la procédure du programme, c'est à peu près comme suit.

Lire les données pour la formation
Formatage des données sous une forme apprenable (prétraitement)
Construire une couche réseau
Apprentissage
Évaluation des performances avec des données d'essai
Affichez une partie du résultat à l'écran et vérifiez
Exporter l'architecture et les poids

Une fois que vous l'avez appris, vous pouvez lire et utiliser l'architecture et les poids exportés à partir de la deuxième fois, vous n'avez donc pas besoin de 3 ou 4. Une fois implémenté, le code ressemble à ceci: Les résultats de l'exécution, etc. sont téléchargés sur Gist, veuillez donc les vérifier si nécessaire.

`rectangle_mlp.py`


import numpy as np
from scipy.misc import toimage
from keras.utils import np_utils
import matplotlib.pyplot as plt

from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation

#Fonction de lecture de données carrées
def load_rectangles_data(filename):
    data = np.loadtxt(filename)
    #Extraction de données d'image
    x = data[:,0:784]
    #Extraction de l'étiquette correcte
    y = data[:,784]
    return [x,y]

#réglages des paramètres
nb_classes = 2
epoch = 20
batch = 10

#étiquette:"Horizontal":Horizontal,"Vertical":Verticale
label = ["Horizontal","Vertical"]

#Lecture des données d'entraînement Square
[X_train,y_train] = load_rectangles_data('rectangles_train.amat')

#Lecture des données de test du carré
[X_test,y_test] = load_rectangles_data('rectangles_test.amat')

#Changer l'étiquette en un tableau correspondant au nombre de classes
#Exemple: y_train:[0 1 0 0] -> Y_train:[[1 0],[0 1],[1 0],[1 0]]
Y_train = np_utils.to_categorical(y_train,nb_classes)
Y_test = np_utils.to_categorical(y_test,nb_classes)

#Création d'un réseau Perceptron multicouche
#Dimensions d'entrée 784(28x28)Et définissez la sortie finale sur le nombre de classes
model = Sequential()
model.add(Dense(512, input_dim=784, init='uniform'))
model.add(Activation('sigmoid'))
model.add(Dropout(0.5))
model.add(Dense(512, init='uniform'))
model.add(Activation('sigmoid'))
model.add(Dropout(0.5))
model.add(Dense(nb_classes, input_dim=512, init='uniform'))
model.add(Activation('softmax'))

#Puisqu'il s'agit d'une classification binaire, sélectionnez binaire et sélectionnez RMSprop comme algorithme d'optimisation.
model.compile(loss='binary_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])

model.fit(X_train, Y_train,
          nb_epoch=epoch,
          batch_size=batch)

#Évaluation du modèle et du poids créés à l'aide des données de test
score = model.evaluate(X_test, Y_test, batch_size=batch)
#Cette fois, le taux de réponse correct est de 92%
print(score)
#Prédire certaines étiquettes des données de test
classified_labels = model.predict_classes(X_test[0:10,:].reshape(-1,784))

#Spécifiez la taille à afficher
plt.figure(figsize=(20,10))
for i in range(10):
    plt.subplot(2,5,i+1)
    #Convertir en données d'image
    img = toimage(X_test[i].reshape(28,28))
    plt.imshow(img, cmap='gray')
    plt.title("Class {}".format(label[classified_labels[i]]),fontsize=20)
    plt.axis('off')
plt.show()

#Exporter les paramètres de modèle et de poids
model_json = model.to_json()
open('rectangles_architecture.json', 'w').write(model_json)
model.save_weights('rectangles_weights.h5', overwrite=True)

résultat

Si vous ajustez les paramètres tels que le nombre d'époques, le nombre de lots et l'algorithme d'optimisation de manière appropriée, il semble que le taux de réponse correct soit d'environ 92% avec cette classification simple. Les résultats de certaines données de test s'affichent. Vous pouvez voir qu'ils sont classés correctement.

Classification à l'aide de données entraînées

Il faut encore du temps pour apprendre. Par conséquent, dans la pratique, la méthode consiste à enregistrer à l'avance les poids appris et à les utiliser. En ce qui concerne ce qu'il faut faire spécifiquement, je pense qu'il est enregistré avec les extensions JSON et h5 à la fin du script précédent, il suffit donc de le charger. c'est simple. Dans ce qui précède, nous avons classé les données de test, mais je ne peux pas croire qu'il puisse classer les données. Par conséquent, j'ai préparé les quatre éléments suivants de données carrées de 56 pixels x 56 pixels, comme il convient pour la peinture. Voyons si cela peut être catégorisé. Si vous regardez les résultats, vous pouvez voir qu'ils sont correctement classés. Le script Python utilisé pour charger et classer est: Les résultats du Jupyter Notebook sont également publiés sur Gist, veuillez donc les vérifier si vous en avez besoin.

`rectangle_load_learned_parameter.py`


import numpy as np
import matplotlib.pyplot as plt

from keras.utils import np_utils

from keras.models import Sequential,model_from_json
from keras.layers import Dense, Dropout, Activation
from keras.preprocessing import image
from keras.applications.imagenet_utils import preprocess_input, decode_predictions

#Une fonction qui binarise les valeurs du tableau à 0 et 1 en spécifiant un seuil
# array:Tableau bidimensionnel, seuil:Seuil
def array2d_binarization(array,threshold):
    (row,column) = array.shape
    for i in range(row):
        for j in range(column):
            if(array[i,j] > threshold):
                array[i,j] = 1
            else:
                array[i,j] = 0
    return array

#Nombre d'images préparées pour le test
test_num = 4

#Signification de l'étiquette identifiée
# "Horizontal":Horizontal,"Vertical":Verticale
label = ["Horizontal","Vertical"]

#Modèle de charge
model = model_from_json(open('rectangles_architecture.json').read())
#Poids du modèle de charge
model.load_weights('rectangles_weights.h5')

for s in range(test_num):
    #Spécifiez le nom du fichier
    img_path = "rectangle" + str(s)+".jpg "
    #28 pixels x 28 pixels, charge l'image en échelle de gris
    img = image.load_img(img_path, grayscale=True, target_size=(28, 28))
    #Convertir l'image chargée en tableau
    x = image.img_to_array(img)
    #Vérification de la taille de la baie
    print(x.shape)
    
    #Binarisez les données d'image avec un seuil de 50, x pour donner 28x28 comme argument[:,:,0]À
    x = array2d_binarization(x[:,:,0],50)
    #Mettre en forme un tableau bidimensionnel 28x28 dans un vecteur de taille 784 pour l'entrée
    x = x.reshape(-1,784)

    #Prédiction de classe
    classified_label = model.predict_classes(x)
    
    #Graphique des résultats de prédiction
    plt.subplot(1,test_num,s+1)
    plt.imshow(img, cmap='gray')
    plt.title("Class {0}".format(label[classified_label[0]]),fontsize=10)
    plt.axis('off')
plt.show()

en conclusion

J'aimerais continuer à écrire des articles sur l'utilisation de Keras en plusieurs parties. La prochaine fois, je parlerai d'un classement un peu plus compliqué. S'il y a des erreurs, nous les corrigerons, veuillez donc les signaler.

[PYTHON] [Windows Edition] Keras Course, une bibliothèque où vous pouvez essayer le Deep Learning immédiatement - Partie 1