Ankündigung beim DevFest Tokyo 2016 -glücklich-Ingenieure-Leben) Ich habe eine Anfrage erhalten, den gesamten Beispielcode zu sehen, also werde ich ihn offenlegen.
DSL mit rohen TensorFlow- und TensorFlow-API-Versionen auf hoher Ebene tf.contrib.learn und TensorFlow als Backend Bei Keras, das das Netzwerk so beschreiben kann, war nichts nebeneinander zu sehen, wie dieselben Daten und dieselbe Methode verwendet würden, um den Unterschied zu bewirken. Ich wollte. Schließlich war ich verwirrt, als ich mir jedes Tutorial ansah, weil ich etwas subtil anderes tat, oder ich war verwirrt.
Ich habe in meiner Forschung nichts gefunden, was unter ähnlichen Bedingungen verglichen wurde, deshalb habe ich beschlossen, Aufzeichnungen zu führen, damit die Leute weniger verwirrt sind. Vorerst werde ich andere Dinge vorbereiten, die auf dem in tf.contrib.learn tutorial basieren.
tf.contrib.learn.datasets.base.load_iris ()sklearn.cross_validation ()--Optimierer
Danach glaube ich nicht, dass es noch viele andere Dinge gibt, aber ich denke, dass sie fast vollständig sind.
Es schien eine Anfrage zu geben, aber ich bin aus zeitlichen Gründen nicht angekommen.
Dann ist es sofort ein Vergleich
――Da Sie alle Prozesse selbst ausführen, ist es gut zu verstehen, dass Sie es richtig ausführen.
import tensorflow as tf
import numpy as np
from sklearn import cross_validation
# 1-Funktion zur Erzeugung heißer Vektoren
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
#Holen Sie sich Daten zufällig mit der angegebenen Stapelgröß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]
#Vorbereitung der Trainingsdaten
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
)
#Eingabeebene
x = tf.placeholder(tf.float32, [None, 4], name='input')
#1. Schicht
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. Schicht
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)
#Schicht 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)
#Ausgabeschicht
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)
#Idealer Ausgabewert
y_ = tf.placeholder(tf.float32, [None, 3], name='teacher_signal')
#Vergleich mit dem idealen Ausgabewert
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
#Was heißt Lernprozess
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):
#Lernprozess
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)})
#Auswertung der Lernergebnisse
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)}))
――Im Vergleich zu rohem TensorFlow ist es so einfach, dass Sie den Beat spüren können! -Wenn Sie API lesen, können Sie "Optimierer", "Dropout" und verschiedene andere Dinge einstellen. Ich denke, ich kann mehr als ich erwartet hatte
import tensorflow as tf
from sklearn import cross_validation
#Vorbereitung der Trainingsdaten
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
)
#Lehren Sie, dass alle Funktionen reelle Zahlen sind
feature_columns = [tf.contrib.layers.real_valued_column("", dimension=4)]
#3-lagiges DNN
#Wenn Sie nichts angeben, scheint die Aktivierungsfunktion ReLU auszuwählen
classifier = tf.contrib.learn.DNNClassifier(feature_columns=feature_columns,
hidden_units=[10, 20, 10],
n_classes=3,
model_dir="./iris_model")
#Modellbefestigung
classifier.fit(x=train_x,
y=train_y,
steps=2000,
batch_size=50)
#Bewertung der Genauigkeit
print(classifier.evaluate(x=test_x, y=test_y)["accuracy"])
――Es ist ganz anders ――Aber beim experimentellen Aufbau eines Netzwerks scheinen die Aussichten viel besser zu sein als bei rohem TensorFlow.
import tensorflow as tf
from keras.models import Sequential
from keras.layers.core import Dense, Activation
from sklearn import cross_validation
#Vorbereitung der Eingabedaten
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
)
#Modelldefinition
model = Sequential()
#Netzwerkdefinition
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'))
#Netzwerk kompilieren
model.compile(loss = 'sparse_categorical_crossentropy',
optimizer = 'sgd',
metrics = ['accuracy'])
#Lernprozess
model.fit(train_x, train_y, nb_epoch = 2000, batch_size = 100)
#Auswertung der Lernergebnisse
loss, metrics = model.evaluate(test_x, test_y)
Es sieht so aus, als würde Pat wie folgt aussehen.
Keras
――Wenn Sie entschieden haben, was zu tun ist, und erkennen können, was Sie mit der bereitgestellten API tun möchten, "tf.learn"Recommended Posts