Come posso separare le esecuzioni del mio codice TensorFlow in TensorBoard?

Question

I miei diagrammi TensorBoard trattano sequenze successive del mio codice TensorFlow come se facessero tutti parte della stessa esecuzione. Per esempio, se prima ho eseguito il mio codice (sotto) con FLAGS.epochs == 10 ed eseguire nuovamente con FLAGS.epochs == 40 ottengo

che "torna indietro" alla fine della prima manche per iniziare il secondo.

C'è un modo per trattare più esecuzioni del mio codice come log distinti, che, ad esempio, potrebbero essere confrontati o visualizzati singolarmente?

---

from __future__ import (absolute_import, print_function, division, unicode_literals) 

import tensorflow as tf 
from tensorflow.examples.tutorials.mnist import input_data 

# Basic model parameters as external flags. 
flags = tf.app.flags 
FLAGS = flags.FLAGS 
flags.DEFINE_float('epochs', 40, 'Epochs to run') 
flags.DEFINE_integer('mb_size', 40, 'Mini-batch size. Must divide evenly into the dataset sizes.') 
lags.DEFINE_float('learning_rate', 0.15, 'Initial learning rate.') 
flags.DEFINE_float('regularization_weight', 0.1/1000, 'Regularization lambda.') 
flags.DEFINE_string('data_dir', './data', 'Directory to hold training and test data.') 
flags.DEFINE_string('train_dir', './_tmp/train', 'Directory to log training (and the network def).') 
flags.DEFINE_string('test_dir', './_tmp/test', 'Directory to log testing.') 

def variable_summaries(var, name): 
    with tf.name_scope("summaries"): 
     mean = tf.reduce_mean(var) 
     tf.scalar_summary('mean/' + name, mean) 
     with tf.name_scope('stddev'): 
      stddev = tf.sqrt(tf.reduce_sum(tf.square(var - mean))) 
      tf.scalar_summary('sttdev/' + name, stddev) 
    tf.scalar_summary('max/' + name, tf.reduce_max(var)) 
    tf.scalar_summary('min/' + name, tf.reduce_min(var)) 
    tf.histogram_summary(name, var) 

def nn_layer(input_tensor, input_dim, output_dim, neuron_fn, layer_name): 
    with tf.name_scope(layer_name): 
     # This Variable will hold the state of the weights for the layer 
     with tf.name_scope("weights"): 
      weights = tf.Variable(tf.truncated_normal([input_dim, output_dim], stddev=0.1)) 
      variable_summaries(weights, layer_name + '/weights') 
     with tf.name_scope("biases"): 
      biases = tf.Variable(tf.constant(0.1, shape=[output_dim])) 
      variable_summaries(biases, layer_name + '/biases') 
     with tf.name_scope('activations'): 
      with tf.name_scope('weighted_inputs'): 
       weighted_inputs = tf.matmul(input_tensor, weights) + biases 
       tf.histogram_summary(layer_name + '/weighted_inputs', weighted_inputs) 
      output = neuron_fn(weighted_inputs) 
      tf.histogram_summary(layer_name + '/output', output) 
    return output, weights 

# Collect data 
mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True) 

# Inputs and outputs 
x = tf.placeholder(tf.float32, shape=[None, 784]) 
y_ = tf.placeholder(tf.float32, shape=[None, 10]) 

# Network structure 
o1, W1 = nn_layer(x, 784, 30, tf.nn.sigmoid, 'hidden_layer') 
y, W2 = nn_layer(o1, 30, 10, tf.nn.softmax, 'output_layer') 

with tf.name_scope('accuracy'): 
    with tf.name_scope('loss'): 
     cost = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1])) 
     loss = cost + FLAGS.regularization_weight * (tf.nn.l2_loss(W1) + tf.nn.l2_loss(W2)) 
    with tf.name_scope('correct_prediction'): 
     correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1)) 
    with tf.name_scope('accuracy'): 
     accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) 
    tf.scalar_summary('accuracy', accuracy) 
    tf.scalar_summary('loss', loss) 

train_step = tf.train.GradientDescentOptimizer(FLAGS.learning_rate).minimize(loss) 

# Logging 
train_writer = tf.train.SummaryWriter(FLAGS.train_dir, tf.get_default_graph()) 
test_writer = tf.train.SummaryWriter(FLAGS.test_dir) 
merged = tf.merge_all_summaries() 

with tf.Session() as sess: 
    sess.run(tf.initialize_all_variables()) 

    for ep in range(FLAGS.epochs): 
     for mb in range(int(len(mnist.train.images)/FLAGS.mb_size)): 
      batch_xs, batch_ys = mnist.train.next_batch(FLAGS.mb_size) 
      sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys}) 

     summary = sess.run(merged, feed_dict={x: mnist.test.images, y_: mnist.test.labels}) 
     test_writer.add_summary(summary, ep+1) 

Answer 1

from fs.osfs import OSFS 
folder = OSFS(FLAGS.test_dir) 
test_n = len(list(n for n in folder.listdir() if n.startswith('test'))) 
this_test = FLAGS.test_dir+"/test" + str(test_n+1) 
test_writer = tf.train.SummaryWriter(this_test) 

Si potrebbe usare qualcosa di simile per avere le tue corse enumerati.

Answer 2

È possibile utilizzare il (di basso livello) modulo "tempo" per ottenere una stringa per ogni volta che la corsa comincia, e il nome della directory di conseguenza ..

Ecco un esempio utilizzando keras con il backend tensorflow

from keras.callbacks import TensorBoard 
import time 

now = time.strftime("%c") 
model.fit(X, Y, batch_size = 2, nb_epoch = 100, shuffle = True, 
     verbose = 1, validation_split = 0.1, 
     callbacks =[TensorBoard(log_dir='./logs/'+now, histogram_freq=0, write_graph=True)]) 

questo vi darà una serie di directory come

% ls logs 
Fri Sep 2 23:58:39 2016/ Sat Sep 3 00:05:41 2016/ 

... sì, i nomi hanno spazi tra loro, ma Tensorboard non mente. Verrà visualizzato un elenco di esecuzioni, con codifica a colori e con data e ora in base a quando sono stati avviati.

Answer 3

È possibile inserire le tue corse in sottodirectory separate, come:

./logdir/2016111301/ 
./logdir/2016111302/ 
./logdir/2016111401/ 

che si chiama la funzione tensorboard sulla directory di root:

tensorboard --logdir=logdir 

Than avrete i file di log separati come: