Keras était à l'origine une bibliothèque utilisée en combinaison avec le framework Deep Learning Theano, mais avec une mise à jour récente, TensorFlow de Google peut également être utilisé comme backend.
Keras: Deep Learning library for Theano and TensorFlow
You have just found Keras.
Keras is a minimalist, highly modular neural networks library, written in Python and capable of running either on top of either TensorFlow or Theano. It was developed with a focus on enabling fast experimentation. Being able to go from idea to result with the least possible delay is key to doing good research.
Étant donné que Theano prend principalement en charge la partie de base du fonctionnement des tenseurs, il est raisonnable qu'il existe des bibliothèques plus abstraites basées sur Theano, mais il prend en charge un plus large éventail de fonctions. J'ai été un peu surpris que Keras prenne en charge TensorFlow. Ci-dessous, j'ai étudié la situation en créant un code simple.
(L'environnement du programme est Linux Ubuntu 14.04, Python 2.7.11, Theano ver.0.7.0, TensorFlow ver.0.6.0, Keras ver.0.3.0.)
Theano et ThensorFlow ont été installés dans un environnement où le GPU peut être utilisé auparavant. Cette fois, "Keras" a été ajouté.
> git clone https://github.com/fchollet/keras.git
> cd keras
> python setup.py install
À l'exception du répertoire des exemples, un exemple de code est fourni pour les problèmes typiques.
> ls examples
addition_rnn.py imdb_bidirectional_lstm.py kaggle_otto_nn.py mnist_mlp.py
babi_memnn.py imdb_cnn.py lstm_text_generation.py mnist_transfer_cnn.py
babi_rnn.py imdb_cnn_lstm.py mnist_cnn.py reuters_mlp.py
cifar10_cnn.py imdb_lstm.py mnist_irnn.py
Parmi eux, 'mnist_mlp.py' était un exemple de MNIST (problème de classification des nombres manuscrits), donc quand j'ai exécuté ceci, une erreur s'est produite au début.
Traceback (most recent call last):
File "mnist_mlp.py", line 50, in <module>
model.compile(loss='categorical_crossentropy', optimizer=rms)
...
(Omis)
...
File "build/bdist.linux-x86_64/egg/keras/activations.py", line 25, in relu
File "build/bdist.linux-x86_64/egg/keras/backend/theano_backend.py", line 463, in relu
AttributeError: 'module' object has no attribute 'relu'
Ceci est dû au fait que "relu" était spécifié comme fonction d'activation dans "minist_mlp.py", mais il n'était pas pris en charge par la version Theano ver.0.7.0, qui était à l'origine installée par Anaconda. .. (Le document de Theno indique que "Relu" est pris en charge à partir de la version 0.7.1.) Cependant, Theano sur GitHub a "Relu" (bien que la version 0.7.0). Ainsi, lorsque j'ai amélioré cela, l'erreur ci-dessus a disparu.
(Omis)
...
Epoch 20/20
1s - loss: 0.0092 - acc: 0.9974 - val_loss: 0.0555 - val_acc: 0.9842
Test score: 0.0554862711126
Test accuracy: 0.9842
La précision de classification de Test est d'environ 98,4%.
Il existe deux façons de changer la fin de la banque.
{" epsilon ": 1e-07," floatx ":" float32 "," backend ":" theano "}, donc le dernier terme, "theano" Changez-le en "thensorfolw".export KERAS_BACKEND=tensorflow
Avec cela seul, le même code Keras peut être exécuté à l'aide de la bibliothèque TensorFlow. (Très facile!) En comparant les deux méthodes, la définition des variables d'environnement semble être plus facile. (Bien sûr, pour revenir à theono, vous pouvez soit définir la variable d'environnement ci-dessus sur ʻunset`, soit la définir sur'theano '.)
En passant, les résultats du test de performance sont affichés ici, je vais donc les citer. https://github.com/fchollet/keras/wiki/Keras,-now-running-on-TensorFlow
| Task | TensorFlow | Theano |
|---|---|---|
| mnist_mlp.py: compilation (s) | 0.6 | 5.9 |
| mnist_mlp.py: runtime/epoch (s) | 7.5 | 6.3 |
| imdb_lstm.py: compilation (s) | 39.3 | 38.3 |
| imdb_lstm.py: runtime/epoch (s) | 283 | 123 |
| mnist_cnn.py: compilation (s) | 0.8 | 11.4 |
| mnist_cnn.py: runtime/epoch (s) | 190 | 3230 |
Même si vous exécutez le même code pour le même problème, vous pouvez voir que le temps requis change considérablement en fonction de la fin de la banque. (Il semble que cela soit dû au calcul du processeur.)
J'ai essayé de changer le code MLP de classification Wine de la version TensorFlow / version Theano, qui a été traité dans l'article récemment publié, vers la version Keras. C'est un code court que j'ai écrit pour Tutorial, mais il est encore plus compact dans la version Keras. (Pour le code d'origine, reportez-vous à la version TensorFlow, version Theano.
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
np.random.seed(1337) # for reproducibility
from keras.models import Sequential
from keras.layers.core import Dense, Activation, Dropout
from keras.regularizers import l2
from keras.optimizers import SGD, Adagrad
from input_winedata import load_data
if __name__ == '__main__':
WineData = '../../Data/Wine/wine.data'
train_x, train_y, test_x, test_y = load_data(WineData)
print(train_x.shape[0], 'train samples')
print(test_x.shape[0], 'test samples')
model = Sequential()
model.add(Dense(20, input_shape=(13,), W_regularizer=l2(0.001)))
model.add(Activation('sigmoid'))
model.add(Dropout(0.05))
model.add(Dense(20, W_regularizer=l2(0.001)))
model.add(Activation('sigmoid'))
model.add(Dropout(0.05))
model.add(Dense(3, W_regularizer=l2(0.001)))
model.add(Activation('softmax'))
adagrad = Adagrad(lr=0.01, epsilon=1e-08)
model.compile(loss='categorical_crossentropy', optimizer=adagrad)
batch_size = 16
nb_epoch = 1000
print('Train...')
model.fit(train_x, train_y,
batch_size=batch_size, nb_epoch=nb_epoch,
show_accuracy=False, verbose=2,
validation_data=(test_x, test_y))
score = model.evaluate(test_x, test_y,
show_accuracy=True, verbose=0)
print('Test score:', score[0])
print('Test accuracy:', score[1])
Ci-dessous, nous confirmerons les détails.
Après avoir saisi les données au début, la définition du modèle de réseau (MLP) est effectuée. Même dans Theano et TensorFlow, si vous définissez la couche de couche masquée Classe et la couche de couche de sortie Classe, la partie de définition MLP principale peut être résumée de manière assez concise, mais dans Keras, vous n'avez pas à créer la classe vous-même, le code suivant Le réseau peut être défini avec.
model = Sequential()
model.add(Dense(20, input_shape=(13,), W_regularizer=l2(0.001)))
model.add(Activation('sigmoid'))
model.add(Dropout(0.05))
model.add(Dense(20, W_regularizer=l2(0.001)))
model.add(Activation('sigmoid'))
model.add(Dropout(0.05))
model.add(Dense(3, W_regularizer=l2(0.001)))
model.add(Activation('softmax'))
Choisissez de définir un réseau à propagation directe avec le premier model = Sequential (). Ensuite, du côté de l'entrée (définition de la couche cachée 1), (définition de la couche cachée 2) et (définition de la couche de sortie) sont effectuées dans cet ordre. Vous pouvez écrire très clairement, par exemple en sélectionnant une fonction d'activation, en spécifiant un Rezularizer et en spécifiant un abandon.
À propos, le modèle de réseau de propagation avant model = Sequential () peut prendre en charge jusqu'à CNN (Convolutional Neural Network), et pour RNN (Recurrent Neural Net) etc. avec une structure plus compliquée, dans Keras, model = Graph () La structure peut être définie par le modèle Graph en commençant par la déclaration . (Je voudrais étudier cela à l'avenir.)
Dans la seconde moitié du code MLP, spécifiez l'optimiseur et appelez la méthode de model.fit ().
adagrad = Adagrad(lr=0.01, epsilon=1e-08)
model.compile(loss='categorical_crossentropy', optimizer=adagrad)
batch_size = 16
nb_epoch = 1000
print('Train...')
model.fit(train_x, train_y,
batch_size=batch_size, nb_epoch=nb_epoch,
show_accuracy=False, verbose=2,
validation_data=(test_x, test_y))
Avec ce qui précède, le programme est exécuté jusqu'à l'apprentissage.
Mieux encore, c'est formidable de pouvoir définir un réseau et effectuer des calculs sans script séparé tel que "YAML" ou "Lua". Avec les deux types de backends, "Theano" et "TensorFlow", je ne vois aucune utilisation intéressante à ce stade, mais il ne fait aucun doute que la façade pour les utilisateurs va s'étendre.
De plus, comme on le dit souvent, le compromis entre la perte de flexibilité due à une abstraction accrue s'applique naturellement aussi à "Keras". Cependant, cela semble être une bibliothèque très utile dans le but de «Je veux essayer mon modèle immédiatement» ou «Je veux répéter des expériences numériques d'hyperparamètres» en prototypage. (Je suis devenu un partisan de Keras à la fois.)
Recommended Posts