Comparez le TensorFlow brut avec tf.contrib.learn et Keras

Qu'est-ce que c'est?

Annonce au DevFest Tokyo 2016 -happy-engineer-life) J'ai reçu une demande pour voir l'exemple de code complet, je vais donc l'exposer.

Ce que je voulais faire

DSL avec TensorFlow brut et version API de haut niveau de TensorFlow tf.contrib.learn et TensorFlow comme backend Avec Keras, qui peut décrire le réseau comme ça, rien ne pouvait être vu côte à côte sur la façon dont les mêmes données et la même méthode seraient utilisées pour organiser et différer. Je voulais. Après tout, quand j'ai regardé chaque tutoriel, j'étais confus parce que je faisais quelque chose de subtilement différent, ou j'étais confus.

Je n'ai rien trouvé de comparé dans des conditions similaires dans mes recherches, alors j'ai décidé de garder un dossier pour que les gens soient moins confus. Pour le moment, je préparerai d'autres choses basées sur celle du tutoriel tf.contrib.learn.

Conditions alignées

Les choses qui ne sont pas alignées

--Optimiseur --Réglage de la valeur initiale du réseau

Après cela, je ne pense pas qu'il y ait beaucoup d'autres choses, mais je pense qu'elles sont presque terminées.

Ce que tu n'as pas fait

Il semblait y avoir une demande, mais je ne suis pas arrivé faute de temps.

Comparaison

Alors c'est une comparaison immédiatement

Version brute de TensorFlow

―― Puisque vous effectuez vous-même tous les processus, il semble bon de comprendre que vous le faites correctement.

import tensorflow as tf
import numpy as np
from sklearn import cross_validation

# 1-Fonction pour la génération de vecteurs chauds
def one_hot_labels(labels):
    return np.array([
        np.where(labels == 0, [1], [0]),
        np.where(labels == 1, [1], [0]),
        np.where(labels == 2, [1], [0])
    ]).T

#Obtenir des données de manière aléatoire avec la taille de lot spécifiée
def next_batch(data, label, batch_size):
    perm = np.arange(data.shape[0])
    np.random.shuffle(perm)
    return data[perm][:batch_size], label[perm][:batch_size]

#Préparation des données d'entraînement
iris = tf.contrib.learn.datasets.base.load_iris()

train_x, test_x, train_y, test_y = cross_validation.train_test_split(
    iris.data, iris.target, test_size=0.2
)

#Couche d'entrée
x = tf.placeholder(tf.float32, [None, 4], name='input')

#1ère couche
W1 = tf.Variable(tf.truncated_normal([4, 10], stddev=0.5, name='weight1'))
b1 = tf.Variable(tf.constant(0.0, shape=[10], name='bias1'))
h1 = tf.nn.relu(tf.matmul(x,W1) + b1)

#2ème couche
W2 = tf.Variable(tf.truncated_normal([10, 20], stddev=0.5, name='weight2'))
b2 = tf.Variable(tf.constant(0.0, shape=[20], name='bias2'))
h2 = tf.nn.relu(tf.matmul(h1,W2) + b2)

#Couche 3
W3 = tf.Variable(tf.truncated_normal([20, 10], stddev=0.5, name='weight3'))
b3 = tf.Variable(tf.constant(0.0, shape=[10], name='bias3'))
h3 = tf.nn.relu(tf.matmul(h2,W3) + b3)

#Couche de sortie
W4 = tf.Variable(tf.truncated_normal([10, 3], stddev=0.5, name='weight4'))
b4 = tf.Variable(tf.constant(0.0, shape=[3], name='bias4'))
y = tf.nn.softmax(tf.matmul(h3,W4) + b4)

#Valeur de sortie idéale
y_ = tf.placeholder(tf.float32, [None, 3], name='teacher_signal')

#Comparaison avec la valeur de sortie idéale
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))

#Ce qu'on appelle le processus d'apprentissage
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
with tf.Session() as sess:
    sess.run(tf.initialize_all_variables())
    for i in range(2000):
        #Processus d'apprentissage
        batch_size = 100
        batch_train_x, batch_train_y = next_batch(train_x, train_y, batch_size)
        sess.run(train_step, feed_dict={x: batch_train_x, y_: one_hot_labels(batch_train_y)})

    #Évaluation des résultats d'apprentissage
    correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    print(sess.run(accuracy, feed_dict={x: test_x, y_: one_hot_labels(test_y)}))

Version de tf.contrib.learn

――Comparé au TensorFlow brut, c'est si facile que vous pouvez ressentir le rythme! -Si vous lisez API, il semble que vous puissiez définir ʻoptimizer, dropout` et bien d'autres choses. , Je pense que je peux faire plus que prévu

import tensorflow as tf
from sklearn import cross_validation

#Préparation des données d'entraînement
iris = tf.contrib.learn.datasets.base.load_iris()
train_x, test_x, train_y, test_y = cross_validation.train_test_split(
    iris.data, iris.target, test_size=0.2
)

#Apprenez que toutes les fonctionnalités sont des nombres réels
feature_columns = [tf.contrib.layers.real_valued_column("", dimension=4)]

#DNN 3 couches
#Si vous ne spécifiez rien, la fonction d'activation semble sélectionner ReLU
classifier = tf.contrib.learn.DNNClassifier(feature_columns=feature_columns,
                                            hidden_units=[10, 20, 10],
                                            n_classes=3,
                                            model_dir="./iris_model")
#Montage du modèle
classifier.fit(x=train_x,
               y=train_y,
               steps=2000,
               batch_size=50)

#Évaluation de l'exactitude
print(classifier.evaluate(x=test_x, y=test_y)["accuracy"])

Version Keras

――C'est complètement différent «Mais lors de la construction expérimentale d'un réseau, les perspectives semblent bien meilleures que celles du TensorFlow brut.

import tensorflow as tf
from keras.models import Sequential
from keras.layers.core import Dense, Activation
from sklearn import cross_validation

#Préparation des données d'entrée
iris = tf.contrib.learn.datasets.base.load_iris()
train_x, test_x, train_y, test_y = cross_validation.train_test_split(
    iris.data, iris.target, test_size=0.2
)

#Définition du modèle
model = Sequential()

#Définition du réseau
model.add(Dense(input_dim=4, output_dim=10))
model.add(Activation('relu'))
model.add(Dense(input_dim=10, output_dim=20))
model.add(Activation('relu'))
model.add(Dense(input_dim=20, output_dim=10))
model.add(Activation('relu'))
model.add(Dense(output_dim=3))
model.add(Activation('softmax'))

#Compiler le réseau
model.compile(loss = 'sparse_categorical_crossentropy',
              optimizer = 'sgd',
              metrics = ['accuracy'])

#Processus d'apprentissage
model.fit(train_x, train_y, nb_epoch = 2000, batch_size = 100)

#Évaluation des résultats d'apprentissage
loss, metrics = model.evaluate(test_x, test_y)

Considération arbitraire

Il semble que Pat ressemble à ce qui suit. --Si vous travaillez expérimentalement, Keras ――Si vous avez décidé quoi faire et pouvez réaliser ce que vous voulez faire avec l'API fournie, tf.learn --Si vous ne pouvez pas reproduire ce que vous avez fait avec Keras avec tf.learn, ou si vous avez déjà une image de ce que vous voulez implémenter, TensorFlow brut (mais il peut être difficile à déboguer)

TODO qui ne sera probablement pas fait

Recommended Posts

Comparez le TensorFlow brut avec tf.contrib.learn et Keras
Comparez DCGAN et pix2pix avec Keras
J'ai essayé d'implémenter Grad-CAM avec keras et tensorflow
Découvrez Wasserstein GAN avec le modèle Keras et l'optimisation TensorFlow
J'ai touché Tensorflow et keras
MNIST (DCNN) avec Keras (backend TensorFlow)
[TensorFlow] [Keras] Construction d'un réseau neuronal avec Keras
Défiez la classification des images avec TensorFlow2 + Keras 9-Apprentissage, sauvegarde et chargement de modèles-
[Note de lecture] Apprentissage automatique pratique avec Scikit-Learn, Keras et TensorFlow Chapitre 1
Hamburgers et vélos ImageNet classés par Keras
Utilisez TPU et Keras avec Google Colaboratory
Comparez les vitesses d'analyse XML avec Python et Go
Zundokokiyoshi avec TensorFlow
Casser des blocs avec Tensorflow
Défiez la classification des images par TensorFlow2 + Keras 6-Essayez le prétraitement et la classification des images préparées par vous-même-
Examiner la relation entre TensorFlow et Keras pendant la période de transition
Estimation la plus probable de la moyenne et de la variance avec TensorFlow
Analyse d'images par apprentissage profond à partir de Kaggle et Keras
Identifiez le nom de l'image de la fleur avec des keras (flux tenseur)
Comment partager des dossiers avec Docker et Windows avec tensorflow
Challenge classification des images par TensorFlow2 + Keras 3 ~ Visualiser les données MNIST ~
Ce que vous pouvez et ne pouvez pas faire avec Tensorflow 2.x
[Comment!] Apprenez et jouez à Super Mario avec Tensorflow !!
Résumé de Tensorflow / Keras
optuna, keras et titanic
Lecture de données avec TensorFlow
Prévisions de courses de bateaux avec TensorFlow
Tutoriel CIFAR-10 avec Keras
LSTM multivarié avec Keras
Essayez la régression avec TensorFlow
Avec et sans WSGI
2020/02 Python 3.7 + TensorFlow 2.1 + Keras 2.3.1 + YOLOv3 Détection d'objets avec la dernière version
[TensorFlow 2 / Keras] Comment exécuter l'apprentissage avec CTC Loss dans Keras
Comparez HTTP GET / POST avec cURL (commande) et Python (programmation)
Classification d'images avec un réseau de neurones auto-fabriqué par Keras et PyTorch
Implémentation de versions dérivées de LSTM telles que MGU et SGU avec TensorFlow
Mesurez et comparez les températures avec Raspberry Pi et générez automatiquement des graphiques
Comparez les mots de passe de connexion par hachage avec hashlib de la bibliothèque standard