Ich bin gerade dabei, meine erste Conv. NN-Implementierung in Tensorflow, und haben viele der Tutorials auf Tensorflow website für Einblicke gelesen.TensorFlow: tf.layers vs Low-Level-API
Es scheint, dass es im Wesentlichen zwei Möglichkeiten, sind eine kundenspezifische CNN zu erstellen:
1) Verwendung Tensorflow Schichten tf.layers Module, das der "High-Level-API" ist. Mit dieser Methode definieren Sie eine Modelldefinitionsfunktion, die aus tf.layers-Objekten besteht, und instanziieren Sie in der Hauptfunktion eine und übergeben Sie ihr die Modelldefinitionsfunktion. Von hier aus können die fit() und evaluate() Methoden auf dem Objekt Estimator aufgerufen werden, die jeweils trainieren und validieren. Link: https://www.tensorflow.org/tutorials/layers. Hauptfunktion unter:
def main(unused_argv):
# Load training and eval data
mnist = learn.datasets.load_dataset("mnist")
train_data = mnist.train.images # Returns np.array
train_labels = np.asarray(mnist.train.labels, dtype=np.int32)
eval_data = mnist.test.images # Returns np.array
eval_labels = np.asarray(mnist.test.labels, dtype=np.int32)
# Create the Estimator
mnist_classifier = learn.Estimator(
model_fn=cnn_model_fn, model_dir="/tmp/mnist_convnet_model")
# Set up logging for predictions
# Log the values in the "Softmax" tensor with label "probabilities"
tensors_to_log = {"probabilities": "softmax_tensor"}
logging_hook = tf.train.LoggingTensorHook(
tensors=tensors_to_log, every_n_iter=50)
# Train the model
mnist_classifier.fit(
x=train_data,
y=train_labels,
batch_size=100,
steps=20000,
monitors=[logging_hook])
# Configure the accuracy metric for evaluation
metrics = {
"accuracy":
learn.MetricSpec(
metric_fn=tf.metrics.accuracy, prediction_key="classes"),
}
# Evaluate the model and print results
eval_results = mnist_classifier.evaluate(
x=eval_data, y=eval_labels, metrics=metrics)
print(eval_results)
vollständiger Code here
2) Verwenden Tensorflow der "Low-Level-API", in den Schichten in einer Definitionsfunktion definiert. Hier werden Ebenen manuell definiert und der Benutzer muss viele Berechnungen manuell durchführen. In der Hauptfunktion startet der Benutzer eine tf.Session() und konfiguriert manuell Training/Validierung mit for-Schleife (n). Link: https://www.tensorflow.org/get_started/mnist/pros. Hauptfunktion unter:
def main(_):
# Import data
mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True)
# Create the model
x = tf.placeholder(tf.float32, [None, 784])
# Define loss and optimizer
y_ = tf.placeholder(tf.float32, [None, 10])
# Build the graph for the deep net
y_conv, keep_prob = deepnn(x)
with tf.name_scope('loss'):
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=y_,
logits=y_conv)
cross_entropy = tf.reduce_mean(cross_entropy)
with tf.name_scope('adam_optimizer'):
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
with tf.name_scope('accuracy'):
correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
correct_prediction = tf.cast(correct_prediction, tf.float32)
accuracy = tf.reduce_mean(correct_prediction)
graph_location = tempfile.mkdtemp()
print('Saving graph to: %s' % graph_location)
train_writer = tf.summary.FileWriter(graph_location)
train_writer.add_graph(tf.get_default_graph())
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for i in range(20000):
batch = mnist.train.next_batch(50)
if i % 100 == 0:
train_accuracy = accuracy.eval(feed_dict={
x: batch[0], y_: batch[1], keep_prob: 1.0})
print('step %d, training accuracy %g' % (i, train_accuracy))
train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
print('test accuracy %g' % accuracy.eval(feed_dict={
x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))
Voll Code here
Mein Dilemma ist, ich mag die Einfachheit des neuronalen Netzes definiert, mit tf.layers (Option 1), aber ich möchte die Anpassbarkeit der Ausbildung, die die "Low-Level-API" (Option 2) bietet. Gibt es bei Verwendung der tf.layers-Implementierung eine Möglichkeit, die Validierungsgenauigkeit bei jedem Trainingsnull zu melden? Oder allgemeiner: Kann ich unter Verwendung der tf.Session() trainieren/validieren, oder bin ich darauf beschränkt, die Methoden tf.learn.Estimatorfit() und evaluate() zu verwenden?
Es scheint seltsam, dass man nach Abschluss des gesamten Trainings einen abschließenden Bewertungseffekt haben möchte, da ich dachte, der ganze Sinn der Validierung bestehe darin, den Netzwerkfortschritt während des Trainings zu verfolgen. Was wäre sonst der Unterschied zwischen Validierung und Testen?
Jede Hilfe wäre willkommen.