本文档为TensorFlow参考文档，本转载已得到TensorFlow中文社区授权。
This library provides a set of classes and functions that helps train models.
The Optimizer base class provides methods to compute gradients for a loss and apply gradients to variables. A collection of subclasses implement classic optimization algorithms such as GradientDescent and Adagrad.
You never instantiate the Optimizer class itself, but instead instantiate one of the subclasses.
Base class for optimizers.
This class defines the API to add Ops to train a model. You never use this class directly, but instead instantiate one of its subclasses such as GradientDescentOptimizer, AdagradOptimizer, or MomentumOptimizer.
In the training program you will just have to run the returned Op.
# Execute opt_op to do one step of training: opt_op.run()Calling minimize() takes care of both computing the gradients and applying them to the variables. If you want to process the gradients before applying them you can instead use the optimizer in three steps:
Compute the gradients with compute_gradients().Process the gradients as you wish.Apply the processed gradients with apply_gradients().Example:
# Create an optimizer. opt = GradientDescentOptimizer(learning_rate=0.1) # Compute the gradients for a list of variables. grads_and_vars = opt.compute_gradients(loss, <list of variables>) # grads_and_vars is a list of tuples (gradient, variable). Do whatever you # need to the 'gradient' part, for example cap them, etc. capped_grads_and_vars = [(MyCapper(gv[0]), gv[1])) for gv in grads_and_vars] # Ask the optimizer to apply the capped gradients. opt.apply_gradients(capped_grads_and_vars)Create a new Optimizer.
This must be called by the constructors of subclasses.
Add operations to minimize 'loss' by updating 'var_list'.
This method simply combines calls compute_gradients() and apply_gradients(). If you want to process the gradient before applying them call compute_gradients() and apply_gradients() explicitly instead of using this function.
An Operation that updates the variables in 'var_list'. If 'global_step' was not None, that operation also increments global_step.
Compute gradients of "loss" for the variables in "var_list".
This is the first part of minimize(). It returns a list of (gradient, variable) pairs where "gradient" is the gradient for "variable". Note that "gradient" can be a Tensor, a IndexedSlices, or None if there is no gradient for the given variable.
A list of (gradient, variable) pairs.
Apply gradients to variables.
This is the second part of minimize(). It returns an Operation that applies gradients.
An Operation that applies the specified gradients. If 'global_step' was not None, that operation also increments global_step.
Both minimize() and compute_gradients() accept a gate_gradient argument that controls the degree of parallelism during the application of the gradients.
The possible values are: GATE_NONE, GATE_OP, and GATE_GRAPH.
GATE_NONE: Compute and apply gradients in parallel. This provides the maximum parallelism in execution, at the cost of some non-reproducibility in the results. For example the two gradients of MatMul depend on the input values: With GATE_NONE one of the gradients could be applied to one of the inputs before the other gradient is computed resulting in non-reproducible results.
GATE_OP: For each Op, make sure all gradients are computed before they are used. This prevents race conditions for Ops that generate gradients for multiple inputs where the gradients depend on the inputs.
GATE_GRAPH: Make sure all gradients for all variables are computed before any one of them is used. This provides the least parallelism but can be useful if you want to process all gradients before applying any of them.
Some optimizer subclasses, such as MomentumOptimizer and AdagradOptimizer allocate and manage additional variables associated with the variables to train. These are called Slots. Slots have names and you can ask the optimizer for the names of the slots that it uses. Once you have a slot name you can ask the optimizer for the variable it created to hold the slot value.
This can be useful if you want to log debug a training algorithm, report stats about the slots, etc.
Return a list of the names of slots created by the Optimizer.
See get_slot().
A list of strings.
Return a slot named "name" created for "var" by the Optimizer.
Some Optimizer subclasses use additional variables. For example Momentum and Adagrad use variables to accumulate updates. This method gives access to these Variables if for some reason you need them.
Use get_slot_names() to get the list of slot names created by the Optimizer.
The Variable for the slot if it was created, None otherwise.
Optimizer that implements the gradient descent algorithm.
Construct a new gradient descent optimizer.
Optimizer that implements the Adagrad algorithm.
Construct a new Adagrad optimizer.
Optimizer that implements the Momentum algorithm.
Construct a new Momentum optimizer.
Optimizer that implements the Adam algorithm.
Construct a new Adam optimizer.
Implementation is based on: http://arxiv.org/pdf/1412.6980v7.pdf
Initialization:
m_0 <- 0 (Initialize initial 1st moment vector) v_0 <- 0 (Initialize initial 2nd moment vector) t <- 0 (Initialize timestep)The update rule for variable with gradient g uses an optimization described at the end of section2 of the paper:
t <- t + 1 lr_t <- learning_rate * sqrt(1 - beta2^t) / (1 - beta1^t) m_t <- beta1 * m_{t-1} + (1 - beta1) * g v_t <- beta2 * v_{t-1} + (1 - beta2) * g * g variable <- variable - lr_t * m_t / (sqrt(v_t) + epsilon)The default value of 1e-8 for epsilon might not be a good default in general. For example, when training an Inception network on ImageNet a current good choice is 1.0 or 0.1.
Optimizer that implements the FTRL algorithm.
Construct a new FTRL optimizer.
The Ftrl-proximal algorithm, abbreviated for Follow-the-regularized-leader, is described in the paper Ad Click Prediction: a View from the Trenches.
It can give a good performance vs. sparsity tradeoff.
Ftrl-proximal uses its own global base learning rate and can behave like Adagrad with learning_rate_power=-0.5, or like gradient descent with learning_rate_power=0.0.
The effective learning rate is adjusted per parameter, relative to this base learning rate as:
effective_learning_rate_i = (learning_rate / pow(k + summed_squared_gradients_for_i, learning_rate_power));where k is the small constant initial_accumulator_value.
Note that the real regularization coefficient of |w|^2 for objective function is 1 / lambda_2 if specifying l2 = lambda_2 as argument when using this function.
Optimizer that implements the RMSProp algorithm.
Construct a new RMSProp optimizer.
TensorFlow provides functions to compute the derivatives for a given TensorFlow computation graph, adding operations to the graph. The optimizer classes automatically compute derivatives on your graph, but creators of new Optimizers or expert users can call the lower-level functions below.
Constructs symbolic partial derivatives of ys w.r.t. x in xs.
ys and xs are each a Tensor or a list of tensors. grad_ys is a list of Tensor, holding the gradients received by the ys. The list must be the same length as ys.
gradients() adds ops to the graph to output the partial derivatives of ys with respect to xs. It returns a list of Tensor of length len(xs) where each tensor is the sum(dy/dx) for y in ys.
grad_ys is a list of tensors of the same length as ys that holds the initial gradients for each y in ys. When grad_ys is None, we fill in a tensor of '1's of the shape of y for each y in ys. A user can provide their own initial 'grad_ys` to compute the derivatives using a different initial gradient for each y (e.g., if one wanted to weight the gradient differently for each value in each y).
A list of sum(dy/dx) for each x in xs.
A class listing aggregation methods used to combine gradients.
Computing partial derivatives can require aggregating gradient contributions. This class lists the various methods that can be used to combine gradients in the graph:
ADD_N: All of the gradient terms are summed as part of one operation using the "AddN" op. It has the property that all gradients must be ready before any aggregation is performed. DEFAULT: The system-chosen default aggregation method.Stops gradient computation.
When executed in a graph, this op outputs its input tensor as-is.
When building ops to compute gradients, this op prevents the contribution of its inputs to be taken into account. Normally, the gradient generator adds ops to a graph to compute the derivatives of a specified 'loss' by recursively finding out inputs that contributed to its computation. If you insert this op in the graph it inputs are masked from the gradient generator. They are not taken into account for computing gradients.
This is useful any time you want to compute a value with TensorFlow but need to pretend that the value was a constant. Some examples include:
The EM algorithm where the M-step should not involve backpropagation through the output of the E-step.Contrastive divergence training of Boltzmann machines where, when differentiating the energy function, the training must not backpropagate through the graph that generated the samples from the model.Adversarial training, where no backprop should happen through the adversarial example generation process.A Tensor. Has the same type as input.
TensorFlow provides several operations that you can use to add clipping functions to your graph. You can use these functions to perform general data clipping, but they're particularly useful for handling exploding or vanishing gradients.
Clips tensor values to a specified min and max.
Given a tensor t, this operation returns a tensor of the same type and shape as t with its values clipped to clip_value_min and clip_value_max. Any values less than clip_value_min are set to clip_value_min. Any values greater than clip_value_max are set to clip_value_max.
A clipped Tensor.
Clips tensor values to a maximum L2-norm.
Given a tensor t, and a maximum clip value clip_norm, this operation normalizes t so that its L2-norm is less than or equal to clip_norm'. Specifically, if the L2-norm is already less than or equal toclip_norm, thentis not modified. If the L2-norm is greater thanclip_norm, then this operation returns a tensor of the same type and shape ast` with its values set to:
t * clip_norm / l2norm(t)
In this case, the L2-norm of the output tensor is clip_norm.
This operation is typically used to clip gradients before applying them with an optimizer.
A clipped Tensor.
Clips tensor values to a maximum average L2-norm.
Given a tensor t, and a maximum clip value clip_norm, this operation normalizes t so that its average L2-norm is less than or equal to clip_norm'. Specifically, if the average L2-norm is already less than or equal toclip_norm, thentis not modified. If the average L2-norm is greater thanclip_norm, then this operation returns a tensor of the same type and shape ast` with its values set to:
t * clip_norm / l2norm_avg(t)
In this case, the average L2-norm of the output tensor is clip_norm.
This operation is typically used to clip gradients before applying them with an optimizer.
A clipped Tensor.
Clips values of multiple tensors by the ratio of the sum of their norms.
Given a tuple or list of tensors t_list, and a clipping ratio clip_norm, this operation returns a list of clipped tensors list_clipped and the global norm (global_norm) of all tensors in t_list. Optionally, if you've already computed the global norm for t_list, you can specify the global norm with use_norm.
To perform the clipping, the values t_list[i] are set to:
t_list[i] * clip_norm / max(global_norm, clip_norm)
where:
global_norm = sqrt(sum([l2norm(t)**2 for t in t_list]))
If clip_norm > global_norm then the entries in t_list remain as they are, otherwise they're all shrunk by the global ratio.
Any of the entries of t_list that are of type None are ignored.
This is the correct way to perform gradient clipping (for example, see R. Pascanu, T. Mikolov, and Y. Bengio, "On the difficulty of training Recurrent Neural Networks". http://arxiv.org/abs/1211.5063)
However, it is slower than clip_by_norm() because all the parameters must be ready before the clipping operation can be performed.
Computes the global norm of multiple tensors.
Given a tuple or list of tensors t_list, this operation returns the global norm of the elements in all tensors in t_list. The global norm is computed as:
global_norm = sqrt(sum([l2norm(t)**2 for t in t_list]))
Any entries in t_list that are of type None are ignored.
A 0-D (scalar) Tensor of type float.
Applies exponential decay to the learning rate.
When training a model, it is often recommended to lower the learning rate as the training progresses. This function applies an exponential decay function to a provided initial learning rate. It requires a global_step value to compute the decayed learning rate. You can just pass a TensorFlow variable that you increment at each training step.
The function returns the decayed learning rate. It is computed as:
decayed_learning_rate = learning_rate * decay_rate ^ (global_step / decay_steps)If the argument staircase is True, then global_step /decay_steps is an integer division and the decayed learning rate follows a staircase function.
Example: decay every 100000 steps with a base of 0.96:
... global_step = tf.Variable(0, trainable=False) starter_learning_rate = 0.1 learning_rate = tf.exponential_decay(starter_learning_rate, global_step, 100000, 0.96, staircase=True) optimizer = tf.GradientDescent(learning_rate) # Passing global_step to minimize() will increment it at each step. optimizer.minimize(...my loss..., global_step=global_step)A scalar Tensor of the same type as learning_rate. The decayed learning rate.
Some training algorithms, such as GradientDescent and Momentum often benefit from maintaining a moving average of variables during optimization. Using the moving averages for evaluations often improve results significantly.
Maintains moving averages of variables by employing and exponential decay.
When training a model, it is often beneficial to maintain moving averages of the trained parameters. Evaluations that use averaged parameters sometimes produce significantly better results than the final trained values.
The apply() method adds shadow copies of trained variables and add ops that maintain a moving average of the trained variables in their shadow copies. It is used when building the training model. The ops that maintain moving averages are typically run after each training step. The average() and average_name() methods give access to the shadow variables and their names. They are useful when building an evaluation model, or when restoring a model from a checkpoint file. They help use the moving averages in place of the last trained values for evaluations.
The moving averages are computed using exponential decay. You specify the decay value when creating the ExponentialMovingAverage object. The shadow variables are initialized with the same initial values as the trained variables. When you run the ops to maintain the moving averages, each shadow variable is updated with the formula:
shadow_variable -= (1 - decay) * (shadow_variable - variable)
This is mathematically equivalent to the classic formula below, but the use of an assign_sub op (the "-=" in the formula) allows concurrent lockless updates to the variables:
shadow_variable = decay * shadow_variable + (1 - decay) * variable
Reasonable values for decay are close to 1.0, typically in the multiple-nines range: 0.999, 0.9999, etc.
Example usage when creating a training model:
# Create variables. var0 = tf.Variable(...) var1 = tf.Variable(...) # ... use the variables to build a training model... ... # Create an op that applies the optimizer. This is what we usually # would use as a training op. opt_op = opt.minimize(my_loss, [var0, var1]) # Create an ExponentialMovingAverage object ema = tf.train.ExponentialMovingAverage(decay=0.9999) # Create the shadow variables, and add ops to maintain moving averages # of var0 and var1. maintain_averages_op = ema.apply([var0, var1]) # Create an op that will update the moving averages after each training # step. This is what we will use in place of the usuall trainig op. with tf.control_dependencies([opt_op]): training_op = tf.group(maintain_averages_op) ...train the model by running training_op...There are two ways to use the moving averages for evaluations:
Build a model that uses the shadow variables instead of the variables. For this, use the average()method which returns the shadow variable for a given variable.Build a model normally but load the checkpoint files to evaluate by using the shadow variable names. For this use the average_name() method. See the Saver class for more information on restoring saved variables.Example of restoring the shadow variable values:
# Create a Saver that loads variables from their saved shadow values. shadow_var0_name = ema.average_name(var0) shadow_var1_name = ema.average_name(var1) saver = tf.train.Saver({shadow_var0_name: var0, shadow_var1_name: var1}) saver.restore(...checkpoint filename...) # var0 and var1 now hold the moving average valuesCreates a new ExponentialMovingAverage object.
The Apply() method has to be called to create shadow variables and add ops to maintain moving averages.
The optional num_updates parameter allows one to tweak the decay rate dynamically. . It is typical to pass the count of training steps, usually kept in a variable that is incremented at each step, in which case the decay rate is lower at the start of training. This makes moving averages move faster. If passed, the actual decay rate used is:
min(decay, (1 + num_updates) / (10 + num_updates))
Maintains moving averages of variables.
var_list must be a list of Variable or Tensor objects. This method creates shadow variables for all elements of var_list. Shadow variables for Variable objects are initialized to the variable's initial value. For Tensor objects, the shadow variables are initialized to 0.
shadow variables are created with trainable=False and added to the GraphKeys.ALL_VARIABLEScollection. They will be returned by calls to tf.all_variables().
Returns an op that updates all shadow variables as described above.
Note that apply() can be called multiple times with different lists of variables.
An Operation that updates the moving averages.
Returns the name of the Variable holding the average for var.
The typical scenario for ExponentialMovingAverage is to compute moving averages of variables during training, and restore the variables from the computed moving averages during evaluations.
To restore variables, you have to know the name of the shadow variables. That name and the original variable can then be passed to a Saver() object to restore the variable from the moving average value with: saver = tf.train.Saver({ema.average_name(var): var})
average_name() can be called whether or not apply() has been called.
A string: the name of the variable that will be used or was used by the ExponentialMovingAverage classto hold the moving average of var.
Returns the Variable holding the average of var.
A Variable object or None if the moving average of var is not maintained..
See Threading and Queues for how to use threads and queues. For documentation on the Queue API, see Queues.
A coordinator for threads.
This class implements a simple mechanism to coordinate the termination of a set of threads.
Any of the threads can call coord.request_stop() to ask for all the threads to stop. To cooperate with the requests, each thread must check for coord.should_stop() on a regular basis. coord.should_stop()returns True as soon as coord.request_stop() has been called.
A typical thread running with a Coordinator will do something like:
while not coord.should_stop(): ...do some work...A thread can report an exception to the Coordinator as part of the should_stop() call. The exception will be re-raised from the coord.join() call.
Thread code:
try: while not coord.should_stop(): ...do some work... except Exception, e: coord.request_stop(e)Main code:
try: ... coord = Coordinator() # Start a number of threads, passing the coordinator to each of them. ...start thread 1...(coord, ...) ...start thread N...(coord, ...) # Wait for all the threads to terminate. coord.join(threads) except Exception, e: ...exception that was passed to coord.request_stop()After a thread has called coord.request_stop() the other threads have a fixed time to stop, this is called the 'stop grace period' and defaults to 2 minutes. If any of the threads is still alive after the grace period expires coord.join() raises a RuntimeException reporting the laggards.
try: ... coord = Coordinator() # Start a number of threads, passing the coordinator to each of them. ...start thread 1...(coord, ...) ...start thread N...(coord, ...) # Wait for all the threads to terminate, give them 10s grace period coord.join(threads, stop_grace_period_secs=10) except RuntimeException: ...one of the threads took more than 10s to stop after request_stop() ...was called. except Exception: ...exception that was passed to coord.request_stop()Create a new Coordinator.
Wait for threads to terminate.
Blocks until all 'threads' have terminated or request_stop() is called.
After the threads stop, if an 'exc_info' was passed to request_stop, that exception is re-reaised.
Grace period handling: When request_stop() is called, threads are given 'stop_grace_period_secs' seconds to terminate. If any of them is still alive after that period expires, a RuntimeError is raised. Note that if an 'exc_info' was passed to request_stop() then it is raised instead of that RuntimeError.
Request that the threads stop.
After this is called, calls to should_stop() will return True.
Check if stop was requested.
True if a stop was requested.
Wait till the Coordinator is told to stop.
True if the Coordinator is told stop, False if the timeout expired.
Holds a list of enqueue operations for a queue, each to be run in a thread.
Queues are a convenient TensorFlow mechanism to compute tensors asynchronously using multiple threads. For example in the canonical 'Input Reader' setup one set of threads generates filenames in a queue; a second set of threads read records from the files, processes them, and enqueues tensors on a second queue; a third set of threads dequeues these input records to construct batches and runs them through training operations.
There are several delicate issues when running multiple threads that way: closing the queues in sequence as the input is exhausted, correctly catching and reporting exceptions, etc.
The QueueRunner, combined with the Coordinator, helps handle these issues.
Create a QueueRunner.
On construction the QueueRunner adds an op to close the queue. That op will be run if the enqueue ops raise exceptions.
When you later call the create_threads() method, the QueueRunner will create one thread for each op in enqueue_ops. Each thread will run its enqueue op in parallel with the other threads. The enqueue ops do not have to all be the same op, but it is expected that they all enqueue tensors in queue.
Create threads to run the enqueue ops.
This method requires a session in which the graph was launched. It creates a list of threads, optionally starting them. There is one thread for each op passed in enqueue_ops.
The coord argument is an optional coordinator, that the threads will use to terminate together and report exceptions. If a coordinator is given, this method starts an additional thread to close the queue when the coordinator requests a stop.
This method may be called again as long as all threads from a previous call have stopped.
A list of threads.
Exceptions raised but not handled by the QueueRunner threads.
Exceptions raised in queue runner threads are handled in one of two ways depending on whether or not a Coordinator was passed to create_threads():
With a Coordinator, exceptions are reported to the coordinator and forgotten by the QueueRunner.Without a Coordinator, exceptions are captured by the QueueRunner and made available in this exceptions_raised property.A list of Python Exception objects. The list is empty if no exception was captured. (No exceptions are captured when using a Coordinator.)
Adds a QueueRunner to a collection in the graph.
When building a complex model that uses many queues it is often difficult to gather all the queue runners that need to be run. This convenience function allows you to add a queue runner to a well known collection in the graph.
The companion method start_queue_runners() can be used to start threads for all the collected queue runners.
Starts all queue runners collected in the graph.
This is a companion method to add_queue_runner(). It just starts threads for all queue runners collected in the graph. It returns the list of all threads.
A list of threads.
The following ops output Summary protocol buffers as serialized string tensors.
You can fetch the output of a summary op in a session, and pass it to a SummaryWriter to append it to an event file. Event files contain Event protos that can contain Summary protos along with the timestamp and step. You can then use TensorBoard to visualize the contents of the event files. See TensorBoard and Summaries for more details.
Outputs a Summary protocol buffer with scalar values.
The input tags and values must have the same shape. The generated summary has a summary value for each tag-value pair in tags and values.
A scalar Tensor of type string. The serialized Summary protocol buffer.
Outputs a Summary protocol buffer with images.
The summary has up to max_images summary values containing images. The images are built from tensor which must be 4-D with shape [batch_size, height, width, channels] and where channelscan be:
1: tensor is interpreted as Grayscale.3: tensor is interpreted as RGB.4: tensor is interpreted as RGBA.The images have the same number of channels as the input tensor. Their values are normalized, one image at a time, to fit in the range [0, 255]. The op uses two different normalization algorithms:
If the input values are all positive, they are rescaled so the largest one is 255.
If any input value is negative, the values are shifted so input value 0.0 is at 127. They are then rescaled so that either the smallest value is 0, or the largest one is 255.
The tag argument is a scalar Tensor of type string. It is used to build the tag of the summary values:
If max_images is 1, the summary value tag is 'tag/image'.If max_images is greater than 1, the summary value tags are generated sequentially as 'tag/image/0', 'tag/image/1', etc.A scalar Tensor of type string. The serialized Summary protocol buffer.
Outputs a Summary protocol buffer with a histogram.
The generated Summary has one summary value containing a histogram for values.
This op reports an OutOfRange error if any value is not finite.
A scalar Tensor of type string. The serialized Summary protocol buffer.
Returns the fraction of zeros in value.
If value is empty, the result is nan.
This is useful in summaries to measure and report sparsity. For example,
z = tf.Relu(...) summ = tf.scalar_summary('sparsity', tf.zero_fraction(z))The fraction of zeros in value, with type float32.
Merges summaries.
This op creates a Summary protocol buffer that contains the union of all the values in the input summaries.
When the Op is run, it reports an InvalidArgument error if multiple values in the summaries to merge use the same tag.
A scalar Tensor of type string. The serialized Summary protocol buffer resulting from the merging.
Merges all summaries collected in the default graph.
If no summaries were collected, returns None. Otherwise returns a scalar Tensor of typestringcontaining the serialized Summary protocol buffer resulting from the merging.
See Summaries and TensorBoard for an overview of summaries, event files, and visualization in TensorBoard.
Writes Summary protocol buffers to event files.
The SummaryWriter class provides a mechanism to create an event file in a given directory and add summaries and events to it. The class updates the file contents asynchronously. This allows a training program to call methods to add data to the file directly from the training loop, without slowing down training.
Creates a SummaryWriter and an event file.
On construction the summary writer creates a new event file in logdir. This event file will contain Event protocol buffers constructed when you call one of the following functions: add_summary(), add_event(), or add_graph().
If you pass a graph_def protocol buffer to the constructor it is added to the event file. (This is equivalent to calling add_graph() later).
TensorBoard will pick the graph from the file and display it graphically so you can interactively explore the graph you built. You will usually pass the graph from the session in which you launched it:
...create a graph... # Launch the graph in a session. sess = tf.Session() # Create a summary writer, add the 'graph_def' to the event file. writer = tf.train.SummaryWriter(<some-directory>, sess.graph_def)The other arguments to the constructor control the asynchronous writes to the event file:
flush_secs: How often, in seconds, to flush the added summaries and events to disk. max_queue: Maximum number of summaries or events pending to be written to disk before one of the 'add' calls block.Adds a Summary protocol buffer to the event file.
This method wraps the provided summary in an Event procotol buffer and adds it to the event file.
You can pass the output of any summary op, as-is, to this function. You can also pass a Summaryprocotol buffer that you manufacture with your own data. This is commonly done to report evaluation results in event files.
Adds an event to the event file.
Adds a GraphDef protocol buffer to the event file.
The graph described by the protocol buffer will be displayed by TensorBoard. Most users pass a graph in the constructor instead.
Flushes the event file to disk.
Call this method to make sure that all pending events have been written to disk.
Flushes the event file to disk and close the file.
Call this method when you do not need the summary writer anymore.
An iterator for reading Event protocol buffers from an event file.
You can use this function to read events written to an event file. It returns a Python iterator that yields Event protocol buffers.
Example: Print the contents of an events file.
for e in tf.summary_iterator(path to events file): print eExample: Print selected summary values.
# This example supposes that the events file contains summaries with a # summary value tag 'loss'. These could have been added by calling # `add_summary()`, passing the output of a scalar summary op created with # with: `tf.scalar_summary(['loss'], loss_tensor)`. for e in tf.summary_iterator(path to events file): for v in e.summary.value: if v.tag == 'loss': print v.simple_valueSee the protocol buffer definitions of Event and Summary for more information about their attributes.
Event protocol buffers.
Small helper to get the global step.
# Creates a variable to hold the global_step. global_step_tensor = tf.Variable(10, trainable=False, name='global_step') # Creates a session. sess = tf.Session() # Initializes the variable. sess.run(global_step_tensor.initializer) print 'global_step:', tf.train.global_step(sess, global_step_tensor) global_step: 10The global step value.
Writes a graph proto on disk.
The graph is written as a binary proto unless as_text is True.
v = tf.Variable(0, name='my_variable') sess = tf.Session() tf.train.write_graph(sess.graph_def, '/tmp/my-model', 'train.pbtxt')