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.
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.
tf.contrib.learn.datasets.base.load_iris ()
--Couche intermédiaire 3, chaque couche est 10, 20, 30sklearn.cross_validation ()--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.
Il semblait y avoir une demande, mais je ne suis pas arrivé faute de temps.
Alors c'est une comparaison immédiatement
―― 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)}))
――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"])
――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)
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)
Recommended Posts