TensorFlow: Upstream latest changes to Git.
Changes:
- Updates to installation instructions.
- Updates to documentation.
- Minor modifications and tests for word2vec.
Base CL: 107284192
diff --git a/README.md b/README.md
index a52845a..2f8dac4 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,66 @@
networks research. The system is general enough to be applicable in a wide
variety of other domains, as well.
+# Download and Setup
+
+For detailed installation instructions, see
+[here](g3doc/get_started/os_setup.md).
+
+## Binary Installation
+
+### Ubuntu/Linux
+
+Make sure you have [pip](https://pypi.python.org/pypi/pip) installed:
+
+```sh
+$ sudo apt-get install python-pip
+```
+
+Install TensorFlow:
+
+```sh
+# For CPU-only version
+$ sudo pip install https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.5.0-cp27-none-linux_x86_64.whl
+
+# For GPU-enabled version
+$ sudo pip install https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow-0.5.0-cp27-none-linux_x86_64.whl
+```
+
+### Mac OS X
+
+Make sure you have [pip](https://pypi.python.org/pypi/pip) installed:
+
+If using `easy_install`:
+
+```sh
+$ sudo easy_install pip
+```
+
+Install TensorFlow (only CPU binary version is currently available).
+
+```sh
+$ sudo pip install https://storage.googleapis.com/tensorflow/mac/tensorflow-0.5.0-py2-none-any.whl
+```
+
+### Try your first TensorFlow program
+
+```sh
+$ python
+
+>>> import tensorflow as tf
+>>> hello = tf.constant('Hello, TensorFlow!')
+>>> sess = tf.Session()
+>>> print sess.run(hello)
+Hello, TensorFlow!
+>>> a = tf.constant(10)
+>>> b = tf.constant(32)
+>>> print sess.run(a+b)
+42
+>>>
+
+```
+
+
##For more information
-* [Installation and setup instructions](/tensorflow/g3doc/get_started/os_setup.md)
* [TensorFlow website](http://tensorflow.org)
diff --git a/tensorflow/core/framework/tensor.proto b/tensorflow/core/framework/tensor.proto
index b42694a..a47c7b7 100644
--- a/tensorflow/core/framework/tensor.proto
+++ b/tensorflow/core/framework/tensor.proto
@@ -10,7 +10,7 @@
message TensorProto {
DataType dtype = 1;
- // Shape of the tensor. TODO(mdevin): sort out the 0-rank issues.
+ // Shape of the tensor. TODO(touts): sort out the 0-rank issues.
TensorShapeProto tensor_shape = 2;
// Only one of the representations below is set, one of "tensor_contents" and
diff --git a/tensorflow/core/kernels/softmax_op.h b/tensorflow/core/kernels/softmax_op.h
index 69bd531..030db4b 100644
--- a/tensorflow/core/kernels/softmax_op.h
+++ b/tensorflow/core/kernels/softmax_op.h
@@ -46,7 +46,7 @@
Eigen::IndexList<Eigen::type2index<1>, int> one_by_class;
one_by_class.set(1, num_classes);
#endif
- // NOTE(mdevin): If you modify this implementation please run
+ // NOTE(touts): If you modify this implementation please run
// the ImageNetSoftmaxFwd benchmark in core_ops_test.cc.
//
// softmax = exp(logits - max(logits along classes));
diff --git a/tensorflow/core/kernels/xent_op.h b/tensorflow/core/kernels/xent_op.h
index edb7d81..46af840 100644
--- a/tensorflow/core/kernels/xent_op.h
+++ b/tensorflow/core/kernels/xent_op.h
@@ -35,7 +35,7 @@
typename TTypes<T>::Matrix scratch,
typename TTypes<T>::Vec loss,
typename TTypes<T>::Matrix backprop) {
- // NOTE(mdevin): This duplicates some of the computations in softmax_op
+ // NOTE(touts): This duplicates some of the computations in softmax_op
// because we need the intermediate (logits -max(logits)) values to
// avoid a log(exp()) in the computation of the loss.
diff --git a/tensorflow/core/lib/histogram/histogram.h b/tensorflow/core/lib/histogram/histogram.h
index 9b655f3..3e1e078 100644
--- a/tensorflow/core/lib/histogram/histogram.h
+++ b/tensorflow/core/lib/histogram/histogram.h
@@ -97,7 +97,7 @@
void Clear();
- // TODO(mdevin): It might be a good idea to provide a AddN(<many values>)
+ // TODO(touts): It might be a good idea to provide a AddN(<many values>)
// method to avoid grabbing/releasing the lock when adding many values.
void Add(double value);
diff --git a/tensorflow/core/public/tensor_shape.h b/tensorflow/core/public/tensor_shape.h
index a889b8b..de4f60e 100644
--- a/tensorflow/core/public/tensor_shape.h
+++ b/tensorflow/core/public/tensor_shape.h
@@ -63,7 +63,7 @@
/// \brief Returns the number of elements in dimension "d".
/// REQUIRES: "0 <= d < dims()"
- // TODO(mdevin): Rename to dimension() to match Eigen::Tensor::dimension()?
+ // TODO(touts): Rename to dimension() to match Eigen::Tensor::dimension()?
int64 dim_size(int d) const {
DCHECK_GE(d, 0);
DCHECK_LT(d, dims());
diff --git a/tensorflow/core/util/event.proto b/tensorflow/core/util/event.proto
index 5d67823..b2d0982 100644
--- a/tensorflow/core/util/event.proto
+++ b/tensorflow/core/util/event.proto
@@ -12,7 +12,7 @@
// Timestamp of the event.
double wall_time = 1;
- // Globale step of the event.
+ // Global step of the event.
int64 step = 2;
oneof what {
diff --git a/tensorflow/examples/android/README.md b/tensorflow/examples/android/README.md
index 8a64415..a7c90fe 100644
--- a/tensorflow/examples/android/README.md
+++ b/tensorflow/examples/android/README.md
@@ -20,7 +20,6 @@
"The external label '//external:android/sdk' is not bound to anything" will
be reported.
-
To build the APK, run this from your workspace root:
```
bazel build //tensorflow/examples/android:tensorflow_demo -c opt --copt=-mfpu=neon
@@ -29,11 +28,19 @@
otherwise non-problematic issue) in Eigen will halt the application during
execution. This issue will be corrected in an upcoming release.
-If adb debugging is enabled on your device, you may instead use the following
-command from your workspace root to automatically build and install:
+If adb debugging is enabled on your Android 5.0 or later device, you may then
+use the following command from your workspace root to install the APK once
+built:
+'''
+adb install -r -g bazel-bin/tensorflow/examples/android/tensorflow_demo_incremental.apk
+'''
+
+Alternatively, a streamlined means of building, installing and running in one
+command is:
```
-bazel mobile-install //tensorflow/examples/android:tensorflow_demo -c opt --copt=-mfpu=neon
+bazel mobile-install //tensorflow/examples/android:tensorflow_demo -c opt --start_app --copt=-mfpu=neon
```
-Add the "--start_app" flag if you wish to automatically start the app after
-installing. Otherwise, find the application icon labeled "Tensorflow Demo".
+If camera permission errors are encountered (possible on Android Marshmallow or
+above), then the adb install command above should be used instead, as it
+automatically grants the required camera permissions with '-g'.
diff --git a/tensorflow/g3doc/api_docs/index.md b/tensorflow/g3doc/api_docs/index.md
index 7234bf4..a4a5b50 100644
--- a/tensorflow/g3doc/api_docs/index.md
+++ b/tensorflow/g3doc/api_docs/index.md
@@ -9,7 +9,7 @@
languages like Go, Java, Javascript, Lua R, and perhaps others. With SWIG, it's
relatively easy to contribute a TensorFlow interface to your favorite language.
-Note: Many practical aspects of ssage are covered in the Mechanics tab, and
+Note: Many practical aspects of usage are covered in the Mechanics tab, and
some additional documentation not specific to any particular language API is
available in the Resources tab.
diff --git a/tensorflow/g3doc/api_docs/python/array_ops.md b/tensorflow/g3doc/api_docs/python/array_ops.md
index eecb442..282e0c6 100644
--- a/tensorflow/g3doc/api_docs/python/array_ops.md
+++ b/tensorflow/g3doc/api_docs/python/array_ops.md
@@ -1,6 +1,10 @@
<!-- This file is machine generated: DO NOT EDIT! -->
# Tensor Transformations
+
+Note: Functions taking `Tensor` arguments can also take anything
+accepted by [`tf.convert_to_tensor`](framework.md#convert_to_tensor).
+
<!-- TOC-BEGIN This section is generated by neural network: DO NOT EDIT! -->
## Contents
* [Casting](#AUTOGENERATED-casting)
diff --git a/tensorflow/g3doc/api_docs/python/client.md b/tensorflow/g3doc/api_docs/python/client.md
index b37057e..3ab0af0 100644
--- a/tensorflow/g3doc/api_docs/python/client.md
+++ b/tensorflow/g3doc/api_docs/python/client.md
@@ -299,7 +299,8 @@
or `Recv` op, there will be no corresponding
[`Operation`](framework.md#Operation) object. In that case, this
will return `None`, and you should instead use the
-[`node_def`](OpError.node_def) to discover information about the op.
+[`OpError.node_def`](#OpError.node_def) to discover information about the
+op.
##### Returns:
@@ -536,7 +537,7 @@
For example, running a [`queue.enqueue()`](io_ops.md#QueueBase.enqueue)
operation may raise `AbortedError` if a
-[`queue.close()`](io_ops.md@QueueBase.close) operation previously ran.
+[`queue.close()`](io_ops.md#QueueBase.close) operation previously ran.
- - -
diff --git a/tensorflow/g3doc/api_docs/python/constant_op.md b/tensorflow/g3doc/api_docs/python/constant_op.md
index 34d2b51..ab19844 100644
--- a/tensorflow/g3doc/api_docs/python/constant_op.md
+++ b/tensorflow/g3doc/api_docs/python/constant_op.md
@@ -1,6 +1,10 @@
<!-- This file is machine generated: DO NOT EDIT! -->
# Constants, Sequences, and Random Values
+
+Note: Functions taking `Tensor` arguments can also take anything
+accepted by [`tf.convert_to_tensor`](framework.md#convert_to_tensor).
+
<!-- TOC-BEGIN This section is generated by neural network: DO NOT EDIT! -->
## Contents
* [Constant Value Tensors](#AUTOGENERATED-constant-value-tensors)
diff --git a/tensorflow/g3doc/api_docs/python/control_flow_ops.md b/tensorflow/g3doc/api_docs/python/control_flow_ops.md
index ad4321f..4d96984 100644
--- a/tensorflow/g3doc/api_docs/python/control_flow_ops.md
+++ b/tensorflow/g3doc/api_docs/python/control_flow_ops.md
@@ -1,6 +1,10 @@
<!-- This file is machine generated: DO NOT EDIT! -->
# Control Flow
+
+Note: Functions taking `Tensor` arguments can also take anything
+accepted by [`tf.convert_to_tensor`](framework.md#convert_to_tensor).
+
<!-- TOC-BEGIN This section is generated by neural network: DO NOT EDIT! -->
## Contents
* [Control Flow Operations](#AUTOGENERATED-control-flow-operations)
diff --git a/tensorflow/g3doc/api_docs/python/framework.md b/tensorflow/g3doc/api_docs/python/framework.md
index e28daaa..0614c68 100644
--- a/tensorflow/g3doc/api_docs/python/framework.md
+++ b/tensorflow/g3doc/api_docs/python/framework.md
@@ -33,7 +33,7 @@
<!-- TOC-END This section was generated by neural network, THANKS FOR READING! -->
-Import names from the framework library.
+Classes and functions for building TensorFlow graphs.
## Core graph data structures <div class="md-anchor" id="AUTOGENERATED-core-graph-data-structures">{#AUTOGENERATED-core-graph-data-structures}</div>
@@ -126,6 +126,10 @@
Returns a serialized `GraphDef` representation of this graph.
+The serialized `GraphDef` can be imported into another `Graph`
+(using [`import_graph_def()`](#import_graph_def)) or used with the
+[C++ Session API](../cc/index.md).
+
This method is thread-safe.
##### Args:
@@ -137,8 +141,7 @@
##### Returns:
- A
- [`GraphDef`](https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/core/framework/graph.proto)
+ A [`GraphDef`](https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/core/framework/graph.proto)
protocol buffer.
diff --git a/tensorflow/g3doc/api_docs/python/image.md b/tensorflow/g3doc/api_docs/python/image.md
index 6b3d6c3..0baa28f 100644
--- a/tensorflow/g3doc/api_docs/python/image.md
+++ b/tensorflow/g3doc/api_docs/python/image.md
@@ -1,32 +1,36 @@
<!-- This file is machine generated: DO NOT EDIT! -->
# Images
+
+Note: Functions taking `Tensor` arguments can also take anything
+accepted by [`tf.convert_to_tensor`](framework.md#convert_to_tensor).
+
<!-- TOC-BEGIN This section is generated by neural network: DO NOT EDIT! -->
## Contents
-* [Encoding and Decoding.](#AUTOGENERATED-encoding-and-decoding.)
+* [Encoding and Decoding](#AUTOGENERATED-encoding-and-decoding)
* [tf.image.decode_jpeg(contents, channels=None, ratio=None, fancy_upscaling=None, try_recover_truncated=None, acceptable_fraction=None, name=None)](#decode_jpeg)
* [tf.image.encode_jpeg(image, format=None, quality=None, progressive=None, optimize_size=None, chroma_downsampling=None, density_unit=None, x_density=None, y_density=None, xmp_metadata=None, name=None)](#encode_jpeg)
* [tf.image.decode_png(contents, channels=None, name=None)](#decode_png)
* [tf.image.encode_png(image, compression=None, name=None)](#encode_png)
-* [Resizing.](#AUTOGENERATED-resizing.)
+* [Resizing](#AUTOGENERATED-resizing)
* [tf.image.resize_images(images, new_height, new_width, method=0)](#resize_images)
* [tf.image.resize_area(images, size, name=None)](#resize_area)
* [tf.image.resize_bicubic(images, size, name=None)](#resize_bicubic)
* [tf.image.resize_bilinear(images, size, name=None)](#resize_bilinear)
* [tf.image.resize_nearest_neighbor(images, size, name=None)](#resize_nearest_neighbor)
-* [Cropping.](#AUTOGENERATED-cropping.)
+* [Cropping](#AUTOGENERATED-cropping)
* [tf.image.resize_image_with_crop_or_pad(image, target_height, target_width)](#resize_image_with_crop_or_pad)
* [tf.image.pad_to_bounding_box(image, offset_height, offset_width, target_height, target_width)](#pad_to_bounding_box)
* [tf.image.crop_to_bounding_box(image, offset_height, offset_width, target_height, target_width)](#crop_to_bounding_box)
* [tf.image.random_crop(image, size, seed=None, name=None)](#random_crop)
* [tf.image.extract_glimpse(input, size, offsets, centered=None, normalized=None, uniform_noise=None, name=None)](#extract_glimpse)
-* [Flipping and Transposing.](#AUTOGENERATED-flipping-and-transposing.)
+* [Flipping and Transposing](#AUTOGENERATED-flipping-and-transposing)
* [tf.image.flip_up_down(image)](#flip_up_down)
* [tf.image.random_flip_up_down(image, seed=None)](#random_flip_up_down)
* [tf.image.flip_left_right(image)](#flip_left_right)
* [tf.image.random_flip_left_right(image, seed=None)](#random_flip_left_right)
* [tf.image.transpose_image(image)](#transpose_image)
-* [Image Adjustments.](#AUTOGENERATED-image-adjustments.)
+* [Image Adjustments](#AUTOGENERATED-image-adjustments)
* [tf.image.adjust_brightness(image, delta, min_value=None, max_value=None)](#adjust_brightness)
* [tf.image.random_brightness(image, max_delta, seed=None)](#random_brightness)
* [tf.image.adjust_contrast(images, contrast_factor, min_value=None, max_value=None)](#adjust_contrast)
@@ -36,7 +40,7 @@
<!-- TOC-END This section was generated by neural network, THANKS FOR READING! -->
-## Encoding and Decoding. <div class="md-anchor" id="AUTOGENERATED-encoding-and-decoding.">{#AUTOGENERATED-encoding-and-decoding.}</div>
+## Encoding and Decoding <div class="md-anchor" id="AUTOGENERATED-encoding-and-decoding">{#AUTOGENERATED-encoding-and-decoding}</div>
TensorFlow provides Ops to decode and encode JPEG and PNG formats. Encoded
images are represented by scalar string Tensors, decoded images by 3-D uint8
@@ -211,7 +215,7 @@
-## Resizing. <div class="md-anchor" id="AUTOGENERATED-resizing.">{#AUTOGENERATED-resizing.}</div>
+## Resizing <div class="md-anchor" id="AUTOGENERATED-resizing">{#AUTOGENERATED-resizing}</div>
The resizing Ops accept input images as tensors of several types. They always
output resized images as float32 tensors.
@@ -376,7 +380,7 @@
-## Cropping. <div class="md-anchor" id="AUTOGENERATED-cropping.">{#AUTOGENERATED-cropping.}</div>
+## Cropping <div class="md-anchor" id="AUTOGENERATED-cropping">{#AUTOGENERATED-cropping}</div>
- - -
@@ -555,7 +559,7 @@
-## Flipping and Transposing. <div class="md-anchor" id="AUTOGENERATED-flipping-and-transposing.">{#AUTOGENERATED-flipping-and-transposing.}</div>
+## Flipping and Transposing <div class="md-anchor" id="AUTOGENERATED-flipping-and-transposing">{#AUTOGENERATED-flipping-and-transposing}</div>
- - -
@@ -687,7 +691,7 @@
-## Image Adjustments. <div class="md-anchor" id="AUTOGENERATED-image-adjustments.">{#AUTOGENERATED-image-adjustments.}</div>
+## Image Adjustments <div class="md-anchor" id="AUTOGENERATED-image-adjustments">{#AUTOGENERATED-image-adjustments}</div>
TensorFlow provides functions to adjust images in various ways: brightness,
contrast, hue, and saturation. Each adjustment can be done with predefined
diff --git a/tensorflow/g3doc/api_docs/python/index.md b/tensorflow/g3doc/api_docs/python/index.md
index 72c0a40..8750d0a 100644
--- a/tensorflow/g3doc/api_docs/python/index.md
+++ b/tensorflow/g3doc/api_docs/python/index.md
@@ -2,336 +2,349 @@
# TensorFlow Python reference documentation
-* <b>[Building Graphs](framework.md)</b>: [class DType](framework.md#DType),
- [class Dimension](framework.md#Dimension),
- [class Graph](framework.md#Graph),
- [class GraphKeys](framework.md#GraphKeys),
- [NoGradient](framework.md#NoGradient),
- [class Operation](framework.md#Operation),
- [class RegisterGradient](framework.md#RegisterGradient),
- [class RegisterShape](framework.md#RegisterShape),
- [class Tensor](framework.md#Tensor),
- [class TensorShape](framework.md#TensorShape),
- [add_to_collection](framework.md#add_to_collection),
- [as_dtype](framework.md#as_dtype),
- [control_dependencies](framework.md#control_dependencies),
- [convert_to_tensor](framework.md#convert_to_tensor),
- [device](framework.md#device),
- [get_collection](framework.md#get_collection),
- [get_default_graph](framework.md#get_default_graph),
- [get_seed](framework.md#get_seed),
- [import_graph_def](framework.md#import_graph_def),
- [name_scope](framework.md#name_scope),
- [op_scope](framework.md#op_scope)
+* **[Building Graphs](framework.md)**:
+ * [`add_to_collection`](framework.md#add_to_collection)
+ * [`as_dtype`](framework.md#as_dtype)
+ * [`control_dependencies`](framework.md#control_dependencies)
+ * [`convert_to_tensor`](framework.md#convert_to_tensor)
+ * [`device`](framework.md#device)
+ * [`Dimension`](framework.md#Dimension)
+ * [`DType`](framework.md#DType)
+ * [`get_collection`](framework.md#get_collection)
+ * [`get_default_graph`](framework.md#get_default_graph)
+ * [`get_seed`](framework.md#get_seed)
+ * [`Graph`](framework.md#Graph)
+ * [`GraphKeys`](framework.md#GraphKeys)
+ * [`import_graph_def`](framework.md#import_graph_def)
+ * [`name_scope`](framework.md#name_scope)
+ * [`NoGradient`](framework.md#NoGradient)
+ * [`op_scope`](framework.md#op_scope)
+ * [`Operation`](framework.md#Operation)
+ * [`RegisterGradient`](framework.md#RegisterGradient)
+ * [`RegisterShape`](framework.md#RegisterShape)
+ * [`Tensor`](framework.md#Tensor)
+ * [`TensorShape`](framework.md#TensorShape)
-* <b>[Constants, Sequences, and Random Values](constant_op.md)</b>: [constant](constant_op.md#constant),
- [fill](constant_op.md#fill),
- [linspace](constant_op.md#linspace),
- [ones](constant_op.md#ones),
- [ones_like](constant_op.md#ones_like),
- [random_normal](constant_op.md#random_normal),
- [random_shuffle](constant_op.md#random_shuffle),
- [random_uniform](constant_op.md#random_uniform),
- [range](constant_op.md#range),
- [set_random_seed](constant_op.md#set_random_seed),
- [truncated_normal](constant_op.md#truncated_normal),
- [zeros](constant_op.md#zeros),
- [zeros_like](constant_op.md#zeros_like)
+* **[Constants, Sequences, and Random Values](constant_op.md)**:
+ * [`constant`](constant_op.md#constant)
+ * [`fill`](constant_op.md#fill)
+ * [`linspace`](constant_op.md#linspace)
+ * [`ones`](constant_op.md#ones)
+ * [`ones_like`](constant_op.md#ones_like)
+ * [`random_normal`](constant_op.md#random_normal)
+ * [`random_shuffle`](constant_op.md#random_shuffle)
+ * [`random_uniform`](constant_op.md#random_uniform)
+ * [`range`](constant_op.md#range)
+ * [`set_random_seed`](constant_op.md#set_random_seed)
+ * [`truncated_normal`](constant_op.md#truncated_normal)
+ * [`zeros`](constant_op.md#zeros)
+ * [`zeros_like`](constant_op.md#zeros_like)
-* <b>[Variables](state_ops.md)</b>: [class IndexedSlices](state_ops.md#IndexedSlices),
- [class Saver](state_ops.md#Saver),
- [class Variable](state_ops.md#Variable),
- [all_variables](state_ops.md#all_variables),
- [assert_variables_initialized](state_ops.md#assert_variables_initialized),
- [assign](state_ops.md#assign),
- [assign_add](state_ops.md#assign_add),
- [assign_sub](state_ops.md#assign_sub),
- [constant_initializer](state_ops.md#constant_initializer),
- [count_up_to](state_ops.md#count_up_to),
- [device](state_ops.md#device),
- [get_checkpoint_state](state_ops.md#get_checkpoint_state),
- [get_variable](state_ops.md#get_variable),
- [get_variable_scope](state_ops.md#get_variable_scope),
- [initialize_all_variables](state_ops.md#initialize_all_variables),
- [initialize_variables](state_ops.md#initialize_variables),
- [latest_checkpoint](state_ops.md#latest_checkpoint),
- [random_normal_initializer](state_ops.md#random_normal_initializer),
- [random_uniform_initializer](state_ops.md#random_uniform_initializer),
- [scatter_add](state_ops.md#scatter_add),
- [scatter_sub](state_ops.md#scatter_sub),
- [scatter_update](state_ops.md#scatter_update),
- [sparse_mask](state_ops.md#sparse_mask),
- [trainable_variables](state_ops.md#trainable_variables),
- [truncated_normal_initializer](state_ops.md#truncated_normal_initializer),
- [uniform_unit_scaling_initializer](state_ops.md#uniform_unit_scaling_initializer),
- [update_checkpoint_state](state_ops.md#update_checkpoint_state),
- [variable_scope](state_ops.md#variable_scope),
- [zeros_initializer](state_ops.md#zeros_initializer)
+* **[Variables](state_ops.md)**:
+ * [`all_variables`](state_ops.md#all_variables)
+ * [`assert_variables_initialized`](state_ops.md#assert_variables_initialized)
+ * [`assign`](state_ops.md#assign)
+ * [`assign_add`](state_ops.md#assign_add)
+ * [`assign_sub`](state_ops.md#assign_sub)
+ * [`constant_initializer`](state_ops.md#constant_initializer)
+ * [`count_up_to`](state_ops.md#count_up_to)
+ * [`device`](state_ops.md#device)
+ * [`get_checkpoint_state`](state_ops.md#get_checkpoint_state)
+ * [`get_variable`](state_ops.md#get_variable)
+ * [`get_variable_scope`](state_ops.md#get_variable_scope)
+ * [`IndexedSlices`](state_ops.md#IndexedSlices)
+ * [`initialize_all_variables`](state_ops.md#initialize_all_variables)
+ * [`initialize_variables`](state_ops.md#initialize_variables)
+ * [`latest_checkpoint`](state_ops.md#latest_checkpoint)
+ * [`random_normal_initializer`](state_ops.md#random_normal_initializer)
+ * [`random_uniform_initializer`](state_ops.md#random_uniform_initializer)
+ * [`Saver`](state_ops.md#Saver)
+ * [`scatter_add`](state_ops.md#scatter_add)
+ * [`scatter_sub`](state_ops.md#scatter_sub)
+ * [`scatter_update`](state_ops.md#scatter_update)
+ * [`sparse_mask`](state_ops.md#sparse_mask)
+ * [`trainable_variables`](state_ops.md#trainable_variables)
+ * [`truncated_normal_initializer`](state_ops.md#truncated_normal_initializer)
+ * [`uniform_unit_scaling_initializer`](state_ops.md#uniform_unit_scaling_initializer)
+ * [`update_checkpoint_state`](state_ops.md#update_checkpoint_state)
+ * [`Variable`](state_ops.md#Variable)
+ * [`variable_scope`](state_ops.md#variable_scope)
+ * [`zeros_initializer`](state_ops.md#zeros_initializer)
-* <b>[Tensor Transformations](array_ops.md)</b>: [cast](array_ops.md#cast),
- [concat](array_ops.md#concat),
- [dynamic_partition](array_ops.md#dynamic_partition),
- [dynamic_stitch](array_ops.md#dynamic_stitch),
- [expand_dims](array_ops.md#expand_dims),
- [gather](array_ops.md#gather),
- [pack](array_ops.md#pack),
- [pad](array_ops.md#pad),
- [rank](array_ops.md#rank),
- [reshape](array_ops.md#reshape),
- [reverse](array_ops.md#reverse),
- [reverse_sequence](array_ops.md#reverse_sequence),
- [shape](array_ops.md#shape),
- [size](array_ops.md#size),
- [slice](array_ops.md#slice),
- [split](array_ops.md#split),
- [squeeze](array_ops.md#squeeze),
- [string_to_number](array_ops.md#string_to_number),
- [tile](array_ops.md#tile),
- [to_bfloat16](array_ops.md#to_bfloat16),
- [to_double](array_ops.md#to_double),
- [to_float](array_ops.md#to_float),
- [to_int32](array_ops.md#to_int32),
- [to_int64](array_ops.md#to_int64),
- [transpose](array_ops.md#transpose),
- [unpack](array_ops.md#unpack)
+* **[Tensor Transformations](array_ops.md)**:
+ * [`cast`](array_ops.md#cast)
+ * [`concat`](array_ops.md#concat)
+ * [`dynamic_partition`](array_ops.md#dynamic_partition)
+ * [`dynamic_stitch`](array_ops.md#dynamic_stitch)
+ * [`expand_dims`](array_ops.md#expand_dims)
+ * [`gather`](array_ops.md#gather)
+ * [`pack`](array_ops.md#pack)
+ * [`pad`](array_ops.md#pad)
+ * [`rank`](array_ops.md#rank)
+ * [`reshape`](array_ops.md#reshape)
+ * [`reverse`](array_ops.md#reverse)
+ * [`reverse_sequence`](array_ops.md#reverse_sequence)
+ * [`shape`](array_ops.md#shape)
+ * [`size`](array_ops.md#size)
+ * [`slice`](array_ops.md#slice)
+ * [`split`](array_ops.md#split)
+ * [`squeeze`](array_ops.md#squeeze)
+ * [`string_to_number`](array_ops.md#string_to_number)
+ * [`tile`](array_ops.md#tile)
+ * [`to_bfloat16`](array_ops.md#to_bfloat16)
+ * [`to_double`](array_ops.md#to_double)
+ * [`to_float`](array_ops.md#to_float)
+ * [`to_int32`](array_ops.md#to_int32)
+ * [`to_int64`](array_ops.md#to_int64)
+ * [`transpose`](array_ops.md#transpose)
+ * [`unpack`](array_ops.md#unpack)
-* <b>[Math](math_ops.md)</b>: [abs](math_ops.md#abs),
- [accumulate_n](math_ops.md#accumulate_n),
- [add](math_ops.md#add),
- [add_n](math_ops.md#add_n),
- [argmax](math_ops.md#argmax),
- [argmin](math_ops.md#argmin),
- [batch_cholesky](math_ops.md#batch_cholesky),
- [batch_matmul](math_ops.md#batch_matmul),
- [batch_matrix_determinant](math_ops.md#batch_matrix_determinant),
- [batch_matrix_inverse](math_ops.md#batch_matrix_inverse),
- [ceil](math_ops.md#ceil),
- [cholesky](math_ops.md#cholesky),
- [complex](math_ops.md#complex),
- [complex_abs](math_ops.md#complex_abs),
- [conj](math_ops.md#conj),
- [cos](math_ops.md#cos),
- [diag](math_ops.md#diag),
- [div](math_ops.md#div),
- [edit_distance](math_ops.md#edit_distance),
- [exp](math_ops.md#exp),
- [floor](math_ops.md#floor),
- [imag](math_ops.md#imag),
- [inv](math_ops.md#inv),
- [invert_permutation](math_ops.md#invert_permutation),
- [listdiff](math_ops.md#listdiff),
- [log](math_ops.md#log),
- [matmul](math_ops.md#matmul),
- [matrix_determinant](math_ops.md#matrix_determinant),
- [matrix_inverse](math_ops.md#matrix_inverse),
- [maximum](math_ops.md#maximum),
- [minimum](math_ops.md#minimum),
- [mod](math_ops.md#mod),
- [mul](math_ops.md#mul),
- [neg](math_ops.md#neg),
- [pow](math_ops.md#pow),
- [real](math_ops.md#real),
- [reduce_all](math_ops.md#reduce_all),
- [reduce_any](math_ops.md#reduce_any),
- [reduce_max](math_ops.md#reduce_max),
- [reduce_mean](math_ops.md#reduce_mean),
- [reduce_min](math_ops.md#reduce_min),
- [reduce_prod](math_ops.md#reduce_prod),
- [reduce_sum](math_ops.md#reduce_sum),
- [round](math_ops.md#round),
- [rsqrt](math_ops.md#rsqrt),
- [segment_max](math_ops.md#segment_max),
- [segment_mean](math_ops.md#segment_mean),
- [segment_min](math_ops.md#segment_min),
- [segment_prod](math_ops.md#segment_prod),
- [segment_sum](math_ops.md#segment_sum),
- [sign](math_ops.md#sign),
- [sin](math_ops.md#sin),
- [sparse_segment_mean](math_ops.md#sparse_segment_mean),
- [sparse_segment_sum](math_ops.md#sparse_segment_sum),
- [sqrt](math_ops.md#sqrt),
- [square](math_ops.md#square),
- [sub](math_ops.md#sub),
- [transpose](math_ops.md#transpose),
- [unique](math_ops.md#unique),
- [unsorted_segment_sum](math_ops.md#unsorted_segment_sum),
- [where](math_ops.md#where)
+* **[Math](math_ops.md)**:
+ * [`abs`](math_ops.md#abs)
+ * [`accumulate_n`](math_ops.md#accumulate_n)
+ * [`add`](math_ops.md#add)
+ * [`add_n`](math_ops.md#add_n)
+ * [`argmax`](math_ops.md#argmax)
+ * [`argmin`](math_ops.md#argmin)
+ * [`batch_cholesky`](math_ops.md#batch_cholesky)
+ * [`batch_matmul`](math_ops.md#batch_matmul)
+ * [`batch_matrix_determinant`](math_ops.md#batch_matrix_determinant)
+ * [`batch_matrix_inverse`](math_ops.md#batch_matrix_inverse)
+ * [`ceil`](math_ops.md#ceil)
+ * [`cholesky`](math_ops.md#cholesky)
+ * [`complex`](math_ops.md#complex)
+ * [`complex_abs`](math_ops.md#complex_abs)
+ * [`conj`](math_ops.md#conj)
+ * [`cos`](math_ops.md#cos)
+ * [`diag`](math_ops.md#diag)
+ * [`div`](math_ops.md#div)
+ * [`edit_distance`](math_ops.md#edit_distance)
+ * [`exp`](math_ops.md#exp)
+ * [`floor`](math_ops.md#floor)
+ * [`imag`](math_ops.md#imag)
+ * [`inv`](math_ops.md#inv)
+ * [`invert_permutation`](math_ops.md#invert_permutation)
+ * [`listdiff`](math_ops.md#listdiff)
+ * [`log`](math_ops.md#log)
+ * [`matmul`](math_ops.md#matmul)
+ * [`matrix_determinant`](math_ops.md#matrix_determinant)
+ * [`matrix_inverse`](math_ops.md#matrix_inverse)
+ * [`maximum`](math_ops.md#maximum)
+ * [`minimum`](math_ops.md#minimum)
+ * [`mod`](math_ops.md#mod)
+ * [`mul`](math_ops.md#mul)
+ * [`neg`](math_ops.md#neg)
+ * [`pow`](math_ops.md#pow)
+ * [`real`](math_ops.md#real)
+ * [`reduce_all`](math_ops.md#reduce_all)
+ * [`reduce_any`](math_ops.md#reduce_any)
+ * [`reduce_max`](math_ops.md#reduce_max)
+ * [`reduce_mean`](math_ops.md#reduce_mean)
+ * [`reduce_min`](math_ops.md#reduce_min)
+ * [`reduce_prod`](math_ops.md#reduce_prod)
+ * [`reduce_sum`](math_ops.md#reduce_sum)
+ * [`round`](math_ops.md#round)
+ * [`rsqrt`](math_ops.md#rsqrt)
+ * [`segment_max`](math_ops.md#segment_max)
+ * [`segment_mean`](math_ops.md#segment_mean)
+ * [`segment_min`](math_ops.md#segment_min)
+ * [`segment_prod`](math_ops.md#segment_prod)
+ * [`segment_sum`](math_ops.md#segment_sum)
+ * [`sign`](math_ops.md#sign)
+ * [`sin`](math_ops.md#sin)
+ * [`sparse_segment_mean`](math_ops.md#sparse_segment_mean)
+ * [`sparse_segment_sum`](math_ops.md#sparse_segment_sum)
+ * [`sqrt`](math_ops.md#sqrt)
+ * [`square`](math_ops.md#square)
+ * [`sub`](math_ops.md#sub)
+ * [`transpose`](math_ops.md#transpose)
+ * [`unique`](math_ops.md#unique)
+ * [`unsorted_segment_sum`](math_ops.md#unsorted_segment_sum)
+ * [`where`](math_ops.md#where)
-* <b>[Control Flow](control_flow_ops.md)</b>: [Assert](control_flow_ops.md#Assert),
- [Print](control_flow_ops.md#Print),
- [add_check_numerics_ops](control_flow_ops.md#add_check_numerics_ops),
- [check_numerics](control_flow_ops.md#check_numerics),
- [count_up_to](control_flow_ops.md#count_up_to),
- [equal](control_flow_ops.md#equal),
- [greater](control_flow_ops.md#greater),
- [greater_equal](control_flow_ops.md#greater_equal),
- [group](control_flow_ops.md#group),
- [identity](control_flow_ops.md#identity),
- [is_finite](control_flow_ops.md#is_finite),
- [is_inf](control_flow_ops.md#is_inf),
- [is_nan](control_flow_ops.md#is_nan),
- [less](control_flow_ops.md#less),
- [less_equal](control_flow_ops.md#less_equal),
- [logical_and](control_flow_ops.md#logical_and),
- [logical_not](control_flow_ops.md#logical_not),
- [logical_or](control_flow_ops.md#logical_or),
- [logical_xor](control_flow_ops.md#logical_xor),
- [no_op](control_flow_ops.md#no_op),
- [not_equal](control_flow_ops.md#not_equal),
- [select](control_flow_ops.md#select),
- [tuple](control_flow_ops.md#tuple),
- [verify_tensor_all_finite](control_flow_ops.md#verify_tensor_all_finite),
- [where](control_flow_ops.md#where)
+* **[Control Flow](control_flow_ops.md)**:
+ * [`add_check_numerics_ops`](control_flow_ops.md#add_check_numerics_ops)
+ * [`Assert`](control_flow_ops.md#Assert)
+ * [`check_numerics`](control_flow_ops.md#check_numerics)
+ * [`count_up_to`](control_flow_ops.md#count_up_to)
+ * [`equal`](control_flow_ops.md#equal)
+ * [`greater`](control_flow_ops.md#greater)
+ * [`greater_equal`](control_flow_ops.md#greater_equal)
+ * [`group`](control_flow_ops.md#group)
+ * [`identity`](control_flow_ops.md#identity)
+ * [`is_finite`](control_flow_ops.md#is_finite)
+ * [`is_inf`](control_flow_ops.md#is_inf)
+ * [`is_nan`](control_flow_ops.md#is_nan)
+ * [`less`](control_flow_ops.md#less)
+ * [`less_equal`](control_flow_ops.md#less_equal)
+ * [`logical_and`](control_flow_ops.md#logical_and)
+ * [`logical_not`](control_flow_ops.md#logical_not)
+ * [`logical_or`](control_flow_ops.md#logical_or)
+ * [`logical_xor`](control_flow_ops.md#logical_xor)
+ * [`no_op`](control_flow_ops.md#no_op)
+ * [`not_equal`](control_flow_ops.md#not_equal)
+ * [`Print`](control_flow_ops.md#Print)
+ * [`select`](control_flow_ops.md#select)
+ * [`tuple`](control_flow_ops.md#tuple)
+ * [`verify_tensor_all_finite`](control_flow_ops.md#verify_tensor_all_finite)
+ * [`where`](control_flow_ops.md#where)
-* <b>[Images](image.md)</b>: [adjust_brightness](image.md#adjust_brightness),
- [adjust_contrast](image.md#adjust_contrast),
- [crop_to_bounding_box](image.md#crop_to_bounding_box),
- [decode_jpeg](image.md#decode_jpeg),
- [decode_png](image.md#decode_png),
- [encode_jpeg](image.md#encode_jpeg),
- [encode_png](image.md#encode_png),
- [extract_glimpse](image.md#extract_glimpse),
- [flip_left_right](image.md#flip_left_right),
- [flip_up_down](image.md#flip_up_down),
- [pad_to_bounding_box](image.md#pad_to_bounding_box),
- [per_image_whitening](image.md#per_image_whitening),
- [random_brightness](image.md#random_brightness),
- [random_contrast](image.md#random_contrast),
- [random_crop](image.md#random_crop),
- [random_flip_left_right](image.md#random_flip_left_right),
- [random_flip_up_down](image.md#random_flip_up_down),
- [resize_area](image.md#resize_area),
- [resize_bicubic](image.md#resize_bicubic),
- [resize_bilinear](image.md#resize_bilinear),
- [resize_image_with_crop_or_pad](image.md#resize_image_with_crop_or_pad),
- [resize_images](image.md#resize_images),
- [resize_nearest_neighbor](image.md#resize_nearest_neighbor),
- [transpose_image](image.md#transpose_image)
+* **[Images](image.md)**:
+ * [`adjust_brightness`](image.md#adjust_brightness)
+ * [`adjust_contrast`](image.md#adjust_contrast)
+ * [`crop_to_bounding_box`](image.md#crop_to_bounding_box)
+ * [`decode_jpeg`](image.md#decode_jpeg)
+ * [`decode_png`](image.md#decode_png)
+ * [`encode_jpeg`](image.md#encode_jpeg)
+ * [`encode_png`](image.md#encode_png)
+ * [`extract_glimpse`](image.md#extract_glimpse)
+ * [`flip_left_right`](image.md#flip_left_right)
+ * [`flip_up_down`](image.md#flip_up_down)
+ * [`pad_to_bounding_box`](image.md#pad_to_bounding_box)
+ * [`per_image_whitening`](image.md#per_image_whitening)
+ * [`random_brightness`](image.md#random_brightness)
+ * [`random_contrast`](image.md#random_contrast)
+ * [`random_crop`](image.md#random_crop)
+ * [`random_flip_left_right`](image.md#random_flip_left_right)
+ * [`random_flip_up_down`](image.md#random_flip_up_down)
+ * [`resize_area`](image.md#resize_area)
+ * [`resize_bicubic`](image.md#resize_bicubic)
+ * [`resize_bilinear`](image.md#resize_bilinear)
+ * [`resize_image_with_crop_or_pad`](image.md#resize_image_with_crop_or_pad)
+ * [`resize_images`](image.md#resize_images)
+ * [`resize_nearest_neighbor`](image.md#resize_nearest_neighbor)
+ * [`transpose_image`](image.md#transpose_image)
-* <b>[Sparse Tensors](sparse_ops.md)</b>: [class SparseTensor](sparse_ops.md#SparseTensor),
- [class SparseTensorValue](sparse_ops.md#SparseTensorValue),
- [shape](sparse_ops.md#shape),
- [sparse_concat](sparse_ops.md#sparse_concat),
- [sparse_fill_empty_rows](sparse_ops.md#sparse_fill_empty_rows),
- [sparse_reorder](sparse_ops.md#sparse_reorder),
- [sparse_retain](sparse_ops.md#sparse_retain),
- [sparse_tensor_to_dense](sparse_ops.md#sparse_tensor_to_dense),
- [sparse_to_dense](sparse_ops.md#sparse_to_dense),
- [sparse_to_indicator](sparse_ops.md#sparse_to_indicator)
+* **[Sparse Tensors](sparse_ops.md)**:
+ * [`shape`](sparse_ops.md#shape)
+ * [`sparse_concat`](sparse_ops.md#sparse_concat)
+ * [`sparse_fill_empty_rows`](sparse_ops.md#sparse_fill_empty_rows)
+ * [`sparse_reorder`](sparse_ops.md#sparse_reorder)
+ * [`sparse_retain`](sparse_ops.md#sparse_retain)
+ * [`sparse_tensor_to_dense`](sparse_ops.md#sparse_tensor_to_dense)
+ * [`sparse_to_dense`](sparse_ops.md#sparse_to_dense)
+ * [`sparse_to_indicator`](sparse_ops.md#sparse_to_indicator)
+ * [`SparseTensor`](sparse_ops.md#SparseTensor)
+ * [`SparseTensorValue`](sparse_ops.md#SparseTensorValue)
-* <b>[Inputs and Readers](io_ops.md)</b>: [class FIFOQueue](io_ops.md#FIFOQueue),
- [class FixedLengthRecordReader](io_ops.md#FixedLengthRecordReader),
- [class IdentityReader](io_ops.md#IdentityReader),
- [class QueueBase](io_ops.md#QueueBase),
- [class RandomShuffleQueue](io_ops.md#RandomShuffleQueue),
- [class ReaderBase](io_ops.md#ReaderBase),
- [class TFRecordReader](io_ops.md#TFRecordReader),
- [class TextLineReader](io_ops.md#TextLineReader),
- [class WholeFileReader](io_ops.md#WholeFileReader),
- [batch](io_ops.md#batch),
- [batch_join](io_ops.md#batch_join),
- [decode_csv](io_ops.md#decode_csv),
- [decode_raw](io_ops.md#decode_raw),
- [limit_epochs](io_ops.md#limit_epochs),
- [match_filenames_once](io_ops.md#match_filenames_once),
- [matching_files](io_ops.md#matching_files),
- [parse_example](io_ops.md#parse_example),
- [parse_single_example](io_ops.md#parse_single_example),
- [placeholder](io_ops.md#placeholder),
- [range_input_producer](io_ops.md#range_input_producer),
- [read_file](io_ops.md#read_file),
- [shuffle_batch](io_ops.md#shuffle_batch),
- [shuffle_batch_join](io_ops.md#shuffle_batch_join),
- [size](io_ops.md#size),
- [slice_input_producer](io_ops.md#slice_input_producer),
- [string_input_producer](io_ops.md#string_input_producer)
+* **[Inputs and Readers](io_ops.md)**:
+ * [`batch`](io_ops.md#batch)
+ * [`batch_join`](io_ops.md#batch_join)
+ * [`decode_csv`](io_ops.md#decode_csv)
+ * [`decode_raw`](io_ops.md#decode_raw)
+ * [`FIFOQueue`](io_ops.md#FIFOQueue)
+ * [`FixedLengthRecordReader`](io_ops.md#FixedLengthRecordReader)
+ * [`IdentityReader`](io_ops.md#IdentityReader)
+ * [`limit_epochs`](io_ops.md#limit_epochs)
+ * [`match_filenames_once`](io_ops.md#match_filenames_once)
+ * [`matching_files`](io_ops.md#matching_files)
+ * [`parse_example`](io_ops.md#parse_example)
+ * [`parse_single_example`](io_ops.md#parse_single_example)
+ * [`placeholder`](io_ops.md#placeholder)
+ * [`QueueBase`](io_ops.md#QueueBase)
+ * [`RandomShuffleQueue`](io_ops.md#RandomShuffleQueue)
+ * [`range_input_producer`](io_ops.md#range_input_producer)
+ * [`read_file`](io_ops.md#read_file)
+ * [`ReaderBase`](io_ops.md#ReaderBase)
+ * [`shuffle_batch`](io_ops.md#shuffle_batch)
+ * [`shuffle_batch_join`](io_ops.md#shuffle_batch_join)
+ * [`size`](io_ops.md#size)
+ * [`slice_input_producer`](io_ops.md#slice_input_producer)
+ * [`string_input_producer`](io_ops.md#string_input_producer)
+ * [`TextLineReader`](io_ops.md#TextLineReader)
+ * [`TFRecordReader`](io_ops.md#TFRecordReader)
+ * [`WholeFileReader`](io_ops.md#WholeFileReader)
-* <b>[Data IO (Python functions)](python_io.md)</b>: [class TFRecordWriter](python_io.md#TFRecordWriter),
- [tf_record_iterator](python_io.md#tf_record_iterator)
+* **[Data IO (Python functions)](python_io.md)**:
+ * [`tf_record_iterator`](python_io.md#tf_record_iterator)
+ * [`TFRecordWriter`](python_io.md#TFRecordWriter)
-* <b>[Neural Network](nn.md)</b>: [avg_pool](nn.md#avg_pool),
- [bias_add](nn.md#bias_add),
- [compute_accidental_hits](nn.md#compute_accidental_hits),
- [conv2d](nn.md#conv2d),
- [depthwise_conv2d](nn.md#depthwise_conv2d),
- [dropout](nn.md#dropout),
- [embedding_lookup](nn.md#embedding_lookup),
- [embedding_lookup_sparse](nn.md#embedding_lookup_sparse),
- [fixed_unigram_candidate_sampler](nn.md#fixed_unigram_candidate_sampler),
- [in_top_k](nn.md#in_top_k),
- [l2_loss](nn.md#l2_loss),
- [l2_normalize](nn.md#l2_normalize),
- [learned_unigram_candidate_sampler](nn.md#learned_unigram_candidate_sampler),
- [local_response_normalization](nn.md#local_response_normalization),
- [log_uniform_candidate_sampler](nn.md#log_uniform_candidate_sampler),
- [max_pool](nn.md#max_pool),
- [max_pool_with_argmax](nn.md#max_pool_with_argmax),
- [moments](nn.md#moments),
- [nce_loss](nn.md#nce_loss),
- [relu](nn.md#relu),
- [relu6](nn.md#relu6),
- [sampled_softmax_loss](nn.md#sampled_softmax_loss),
- [separable_conv2d](nn.md#separable_conv2d),
- [sigmoid](nn.md#sigmoid),
- [sigmoid_cross_entropy_with_logits](nn.md#sigmoid_cross_entropy_with_logits),
- [softmax](nn.md#softmax),
- [softmax_cross_entropy_with_logits](nn.md#softmax_cross_entropy_with_logits),
- [softplus](nn.md#softplus),
- [tanh](nn.md#tanh),
- [top_k](nn.md#top_k),
- [uniform_candidate_sampler](nn.md#uniform_candidate_sampler)
+* **[Neural Network](nn.md)**:
+ * [`avg_pool`](nn.md#avg_pool)
+ * [`bias_add`](nn.md#bias_add)
+ * [`compute_accidental_hits`](nn.md#compute_accidental_hits)
+ * [`conv2d`](nn.md#conv2d)
+ * [`depthwise_conv2d`](nn.md#depthwise_conv2d)
+ * [`dropout`](nn.md#dropout)
+ * [`embedding_lookup`](nn.md#embedding_lookup)
+ * [`embedding_lookup_sparse`](nn.md#embedding_lookup_sparse)
+ * [`fixed_unigram_candidate_sampler`](nn.md#fixed_unigram_candidate_sampler)
+ * [`in_top_k`](nn.md#in_top_k)
+ * [`l2_loss`](nn.md#l2_loss)
+ * [`l2_normalize`](nn.md#l2_normalize)
+ * [`learned_unigram_candidate_sampler`](nn.md#learned_unigram_candidate_sampler)
+ * [`local_response_normalization`](nn.md#local_response_normalization)
+ * [`log_uniform_candidate_sampler`](nn.md#log_uniform_candidate_sampler)
+ * [`max_pool`](nn.md#max_pool)
+ * [`max_pool_with_argmax`](nn.md#max_pool_with_argmax)
+ * [`moments`](nn.md#moments)
+ * [`nce_loss`](nn.md#nce_loss)
+ * [`relu`](nn.md#relu)
+ * [`relu6`](nn.md#relu6)
+ * [`sampled_softmax_loss`](nn.md#sampled_softmax_loss)
+ * [`separable_conv2d`](nn.md#separable_conv2d)
+ * [`sigmoid`](nn.md#sigmoid)
+ * [`sigmoid_cross_entropy_with_logits`](nn.md#sigmoid_cross_entropy_with_logits)
+ * [`softmax`](nn.md#softmax)
+ * [`softmax_cross_entropy_with_logits`](nn.md#softmax_cross_entropy_with_logits)
+ * [`softplus`](nn.md#softplus)
+ * [`tanh`](nn.md#tanh)
+ * [`top_k`](nn.md#top_k)
+ * [`uniform_candidate_sampler`](nn.md#uniform_candidate_sampler)
-* <b>[Running Graphs](client.md)</b>: [class AbortedError](client.md#AbortedError),
- [class AlreadyExistsError](client.md#AlreadyExistsError),
- [class CancelledError](client.md#CancelledError),
- [class DataLossError](client.md#DataLossError),
- [class DeadlineExceededError](client.md#DeadlineExceededError),
- [class FailedPreconditionError](client.md#FailedPreconditionError),
- [class InternalError](client.md#InternalError),
- [class InvalidArgumentError](client.md#InvalidArgumentError),
- [class NotFoundError](client.md#NotFoundError),
- [class OpError](client.md#OpError),
- [class OutOfRangeError](client.md#OutOfRangeError),
- [class PermissionDeniedError](client.md#PermissionDeniedError),
- [class ResourceExhaustedError](client.md#ResourceExhaustedError),
- [class Session](client.md#Session),
- [class UnauthenticatedError](client.md#UnauthenticatedError),
- [class UnavailableError](client.md#UnavailableError),
- [class UnimplementedError](client.md#UnimplementedError),
- [class UnknownError](client.md#UnknownError),
- [get_default_session](client.md#get_default_session)
+* **[Running Graphs](client.md)**:
+ * [`AbortedError`](client.md#AbortedError)
+ * [`AlreadyExistsError`](client.md#AlreadyExistsError)
+ * [`CancelledError`](client.md#CancelledError)
+ * [`DataLossError`](client.md#DataLossError)
+ * [`DeadlineExceededError`](client.md#DeadlineExceededError)
+ * [`FailedPreconditionError`](client.md#FailedPreconditionError)
+ * [`get_default_session`](client.md#get_default_session)
+ * [`InternalError`](client.md#InternalError)
+ * [`InvalidArgumentError`](client.md#InvalidArgumentError)
+ * [`NotFoundError`](client.md#NotFoundError)
+ * [`OpError`](client.md#OpError)
+ * [`OutOfRangeError`](client.md#OutOfRangeError)
+ * [`PermissionDeniedError`](client.md#PermissionDeniedError)
+ * [`ResourceExhaustedError`](client.md#ResourceExhaustedError)
+ * [`Session`](client.md#Session)
+ * [`UnauthenticatedError`](client.md#UnauthenticatedError)
+ * [`UnavailableError`](client.md#UnavailableError)
+ * [`UnimplementedError`](client.md#UnimplementedError)
+ * [`UnknownError`](client.md#UnknownError)
-* <b>[Training](train.md)</b>: [class AdagradOptimizer](train.md#AdagradOptimizer),
- [class AdamOptimizer](train.md#AdamOptimizer),
- [class AggregationMethod](train.md#AggregationMethod),
- [class Coordinator](train.md#Coordinator),
- [class ExponentialMovingAverage](train.md#ExponentialMovingAverage),
- [class FtrlOptimizer](train.md#FtrlOptimizer),
- [class GradientDescentOptimizer](train.md#GradientDescentOptimizer),
- [class MomentumOptimizer](train.md#MomentumOptimizer),
- [class Optimizer](train.md#Optimizer),
- [class QueueRunner](train.md#QueueRunner),
- [class RMSPropOptimizer](train.md#RMSPropOptimizer),
- [class SummaryWriter](train.md#SummaryWriter),
- [add_queue_runner](train.md#add_queue_runner),
- [clip_by_average_norm](train.md#clip_by_average_norm),
- [clip_by_global_norm](train.md#clip_by_global_norm),
- [clip_by_norm](train.md#clip_by_norm),
- [clip_by_value](train.md#clip_by_value),
- [exponential_decay](train.md#exponential_decay),
- [global_norm](train.md#global_norm),
- [global_step](train.md#global_step),
- [gradients](train.md#gradients),
- [histogram_summary](train.md#histogram_summary),
- [image_summary](train.md#image_summary),
- [merge_all_summaries](train.md#merge_all_summaries),
- [merge_summary](train.md#merge_summary),
- [scalar_summary](train.md#scalar_summary),
- [start_queue_runners](train.md#start_queue_runners),
- [stop_gradient](train.md#stop_gradient),
- [summary_iterator](train.md#summary_iterator),
- [write_graph](train.md#write_graph),
- [zero_fraction](train.md#zero_fraction)
+* **[Training](train.md)**:
+ * [`AdagradOptimizer`](train.md#AdagradOptimizer)
+ * [`AdamOptimizer`](train.md#AdamOptimizer)
+ * [`add_queue_runner`](train.md#add_queue_runner)
+ * [`AggregationMethod`](train.md#AggregationMethod)
+ * [`clip_by_average_norm`](train.md#clip_by_average_norm)
+ * [`clip_by_global_norm`](train.md#clip_by_global_norm)
+ * [`clip_by_norm`](train.md#clip_by_norm)
+ * [`clip_by_value`](train.md#clip_by_value)
+ * [`Coordinator`](train.md#Coordinator)
+ * [`exponential_decay`](train.md#exponential_decay)
+ * [`ExponentialMovingAverage`](train.md#ExponentialMovingAverage)
+ * [`FtrlOptimizer`](train.md#FtrlOptimizer)
+ * [`global_norm`](train.md#global_norm)
+ * [`global_step`](train.md#global_step)
+ * [`GradientDescentOptimizer`](train.md#GradientDescentOptimizer)
+ * [`gradients`](train.md#gradients)
+ * [`histogram_summary`](train.md#histogram_summary)
+ * [`image_summary`](train.md#image_summary)
+ * [`merge_all_summaries`](train.md#merge_all_summaries)
+ * [`merge_summary`](train.md#merge_summary)
+ * [`MomentumOptimizer`](train.md#MomentumOptimizer)
+ * [`Optimizer`](train.md#Optimizer)
+ * [`QueueRunner`](train.md#QueueRunner)
+ * [`RMSPropOptimizer`](train.md#RMSPropOptimizer)
+ * [`scalar_summary`](train.md#scalar_summary)
+ * [`start_queue_runners`](train.md#start_queue_runners)
+ * [`stop_gradient`](train.md#stop_gradient)
+ * [`summary_iterator`](train.md#summary_iterator)
+ * [`SummaryWriter`](train.md#SummaryWriter)
+ * [`write_graph`](train.md#write_graph)
+ * [`zero_fraction`](train.md#zero_fraction)
<div class="sections-order" style="display: none;">
<!--
diff --git a/tensorflow/g3doc/api_docs/python/io_ops.md b/tensorflow/g3doc/api_docs/python/io_ops.md
index ab8c4aa..888c499 100644
--- a/tensorflow/g3doc/api_docs/python/io_ops.md
+++ b/tensorflow/g3doc/api_docs/python/io_ops.md
@@ -1,6 +1,10 @@
<!-- This file is machine generated: DO NOT EDIT! -->
# Inputs and Readers
+
+Note: Functions taking `Tensor` arguments can also take anything
+accepted by [`tf.convert_to_tensor`](framework.md#convert_to_tensor).
+
<!-- TOC-BEGIN This section is generated by neural network: DO NOT EDIT! -->
## Contents
* [Placeholders](#AUTOGENERATED-placeholders)
@@ -15,6 +19,7 @@
* [Converting](#AUTOGENERATED-converting)
* [tf.decode_csv(records, record_defaults, field_delim=None, name=None)](#decode_csv)
* [tf.decode_raw(bytes, out_type, little_endian=None, name=None)](#decode_raw)
+ * [Example protocol buffer](#AUTOGENERATED-example-protocol-buffer)
* [tf.parse_example(serialized, names=None, sparse_keys=None, sparse_types=None, dense_keys=None, dense_types=None, dense_defaults=None, dense_shapes=None, name='ParseExample')](#parse_example)
* [tf.parse_single_example(serialized, names=None, sparse_keys=None, sparse_types=None, dense_keys=None, dense_types=None, dense_defaults=None, dense_shapes=None, name='ParseSingleExample')](#parse_single_example)
* [Queues](#AUTOGENERATED-queues)
@@ -1061,109 +1066,106 @@
of bytes divided by the number of bytes to represent out_type.
+
+- - -
+
+### Example protocol buffer <div class="md-anchor" id="AUTOGENERATED-example-protocol-buffer">{#AUTOGENERATED-example-protocol-buffer}</div>
+
+TensorFlow's [recommended format for training
+examples](../../how_tos/reading_data/index.md#standard-tensorflow-format)
+is serialized `Example` protocol buffers, [described
+here](https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/core/example/example.proto).
+They contain `Features`, [described
+here](https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/core/example/feature.proto).
+
- - -
### tf.parse_example(serialized, names=None, sparse_keys=None, sparse_types=None, dense_keys=None, dense_types=None, dense_defaults=None, dense_shapes=None, name='ParseExample') <div class="md-anchor" id="parse_example">{#parse_example}</div>
-Parse Example protos.
+Parses `Example` protos.
-##### Args:
+Parses a number of serialized [`Example`]
+(https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/core/example/example.proto)
+protos given in `serialized`.
+`names` may contain descriptive names for the corresponding serialized protos.
+These may be useful for debugging purposes, but they have no effect on the
+output. If not `None`, `names` must be the same length as `serialized`.
-* <b>serialized</b>: string vector, a batch of binary serialized Example protos.
-* <b>names</b>: A string vector, the names of the serialized protos.
- "names" may contain, e.g., table key (descriptive) names for the
- corresponding serialized protos. These are purely useful for debugging
- purposes, and the presence of values here has no effect on the output.
- "names" may be an empty vector, if no names are available.
- If non-empty, this vector must be the same length as "serialized".
-* <b>sparse_keys</b>: A string list of keys in the Examples' features.
- These keys are associated with sparse values.
-* <b>sparse_types</b>: A list of DTypes.
- This list's length must match that of sparse_keys. Currently
- parse_example supports tf.float32 (FloatList), tf.int64 (Int64List),
- and tf.string (BytesList).
-* <b>dense_keys</b>: A string list of keys in the Examples' features.
- These keys are associated with dense values.
-* <b>dense_types</b>: A list of DTypes.
- This list's length must match that of dense_keys. Currently
- parse_example supports tf.float32 (FloatList), tf.int64 (Int64List),
- and tf.string (BytesList).
-* <b>dense_defaults</b>: A dict of {key:Tensor} (some may be missing).
- The keys of the dict must match the dense_keys of the feature.
- If a key is not present in this dictionary, the corresponding dense
- Feature is required in all elements of serialized.
-* <b>dense_shapes</b>: A list of tuples.
- Entries provide the shape of data in each dense Feature in features.
- The length of dense_shapes must be the same as the length of dense_keys.
- The number of elements in the Feature corresponding to dense_key[j]
- must always have np.prod(dense_shapes[j]) entries.
- If dense_shapes[j] == (D0, D1, ..., DN) then the the shape of output
- Tensor dense_values[j] will be (|serialized|, D0, D1, ..., DN):
- The dense outputs are just the inputs row-stacked by batch.
-* <b>name</b>: (Optional) Name of Op in the graph.
+This op parses serialized examples into a dictionary mapping keys to `Tensor`
+and `SparseTensor` objects respectively, depending on whether the keys appear
+in `sparse_keys` or `dense_keys`.
-##### Returns:
+The key `dense_keys[j]` is mapped to a `Tensor` of type `dense_types[j]` and
+of shape `(serialized.size(),) + dense_shapes[j]`.
- A dictionary mapping keys to Tensors and SparseTensors.
+`dense_defaults` provides defaults for values referenced using `dense_keys`.
+If a key is not present in this dictionary, the corresponding dense `Feature`
+is required in all elements of `serialized`.
- The key dense_keys[j] is mapped to a tensor of type dense_types[j] and
- of shape (serialized.size(),) + dense_shapes[j] (i.e., the dense outputs are
- inputs, reshaped in row-major format and then row-stacked by batch).
+`dense_shapes[j]` provides the shape of each `Feature` entry referenced by
+`dense_keys[j]`. The number of elements in the `Feature` corresponding to
+`dense_key[j]` must always have `np.prod(dense_shapes[j])` entries. The
+returned `Tensor` for `dense_key[j]` has shape `[N] + dense_shape[j]`, where
+`N` is the number of `Example`s in `serialized`.
- The key sparse_keys[j] is mapped to a SparseTensor of type sparse_types[j].
- The SparseTensor represents a ragged matrix. Its indices are [batch, index]
- where "batch" is is the batch entry the value is from, and "index" is the
- value's index in the list of values associated with that feature
- and example. For example, if one expects a tf.float32 sparse feature "ft"
- and three serialized examples are provided:
+The key `sparse_keys[j]` is mapped to a `SparseTensor` of type
+`sparse_types[j]`. The `SparseTensor` represents a ragged matrix.
+Its indices are `[batch, index]` where `batch` is the batch entry the value
+is from, and `index` is the value's index in the list of values associated
+with that feature and example.
- serialized = [
+Examples:
-* <b>features</b>:
- { feature: [ key: { "ft" value: float_list: { value: [1.0, 2.0] } } ] },
-* <b>features</b>:
- { feature: [] },
-* <b>features</b>:
- { feature: [ key: { "ft" value: float_list: { value: [3.0] } } ] }
- ]
+For example, if one expects a `tf.float32` sparse feature `ft` and three
+serialized `Example`s are provided:
- then the output will look like:
+```
+serialized = [
+ features:
+ { feature: [ key: { "ft" value: float_list: { value: [1.0, 2.0] } } ] },
+ features:
+ { feature: [] },
+ features:
+ { feature: [ key: { "ft" value: float_list: { value: [3.0] } } ] }
+]
+```
- {"ft": SparseTensor(indices=[[0, 0], [0, 1], [2, 0]],
- values=[1.0, 2.0, 3.0],
- shape=(3, 2)) }
+then the output will look like:
-##### Raises:
+```
+{"ft": SparseTensor(indices=[[0, 0], [0, 1], [2, 0]],
+ values=[1.0, 2.0, 3.0],
+ shape=(3, 2)) }
+```
+Given two `Example` input protos in `serialized`:
-* <b>ValueError</b>: If sparse and dense keys intersect, or input lengths do not
- match up for sparse_* (similarly for dense_*).
-* <b>TypeError</b>: If an input is malformed.
+```
+[
+ features: {
+ feature: { key: "kw" value: { bytes_list: { value: [ "knit", "big" ] } } }
+ feature: { key: "gps" value: { float_list: { value: [] } } }
+ },
+ features: {
+ feature: { key: "kw" value: { bytes_list: { value: [ "emmy" ] } } }
+ feature: { key: "dank" value: { int64_list: { value: [ 42 ] } } }
+ feature: { key: "gps" value: { } }
+ }
+]
+```
-Example input, format, and output: Just Sparse Inputs
-================================================
+And arguments
-Given two brain.Example input protos:
+```
+ names: ["input0", "input1"],
+ sparse_keys: ["kw", "dank", "gps"]
+ sparse_types: [DT_STRING, DT_INT64, DT_FLOAT]
+```
+Then the output is a dictionary:
-* <b>serialized</b>: // serialized versions of the protos below
- [features: {
-
-* <b>feature</b>: { key: "kw" value: { bytes_list: { value: [ "knit", "big" ] } } }
-* <b>feature</b>: { key: "gps" value: { float_list: { value: [] } } }
- },
-* <b>features</b>: {
-* <b>feature</b>: { key: "kw" value: { bytes_list: { value: [ "emmy" ] } } }
-* <b>feature</b>: { key: "dank" value: { int64_list: { value: [ 42 ] } } }
-* <b>feature</b>: { key: "gps" value: { } }
- }]
-
-* <b>names</b>: ["input0", "input1"],
-* <b>sparse_keys</b>: ["kw", "dank", "gps"]
-* <b>sparse_types</b>: [DT_STRING, DT_INT64, DT_FLOAT]
-
-Then the expected output is a dictionary:
+```python
{
"kw": SparseTensor(
indices=[[0, 0], [0, 1], [1, 0]],
@@ -1178,78 +1180,96 @@
values=[],
shape=[2, 0]),
}
+```
+For dense results in two serialized `Example`s:
-Example input, format, and output: Dense Inputs (without defaults)
-==================================================================
-
-Given two brain.Example input protos:
-
-
-* <b>serialized</b>: // serialized versions of the protos below
- [features: {
-
-* <b>feature</b>: { key: "age" value: { int64_list: { value: [ 0 ] } } }
-* <b>feature</b>: { key: "gender" value: { bytes_list: { value: [ "f" ] } } }
+```
+[
+ features: {
+ feature: { key: "age" value: { int64_list: { value: [ 0 ] } } }
+ feature: { key: "gender" value: { bytes_list: { value: [ "f" ] } } }
},
-* <b>features</b>: {
-* <b>feature</b>: { key: "age" value: { int64_list: { value: [] } } }
-* <b>feature</b>: { key: "gender" value: { bytes_list: { value: [ "f" ] } } }
- }]
+ features: {
+ feature: { key: "age" value: { int64_list: { value: [] } } }
+ feature: { key: "gender" value: { bytes_list: { value: [ "f" ] } } }
+ }
+]
+```
-* <b>names</b>: ["input0", "input1"],
-* <b>dense_keys</b>: np.array(["age", "gender"])
-* <b>dense_types</b>: [tf.int64, tf.string]
-* <b>dense_defaults</b>: {
- "age": -1 # defaults to -1 if missing
+We can use arguments:
+
+```
+names: ["input0", "input1"],
+dense_keys: np.array(["age", "gender"]),
+dense_types: [tf.int64, tf.string],
+dense_defaults: {
+ "age": -1 # "age" defaults to -1 if missing
# "gender" has no specified default so it's required
}
+dense_shapes: [(1,), (1,)], # age, gender, label, weight
+```
-* <b>dense_shapes</b>: [(1,), (1,)] # age, gender, label, weight
+And the expected output is:
-Then the expected output is a dictionary:
+```python
{
"age": [[0], [-1]],
"gender": [["f"], ["f"]],
}
+```
+
+##### Args:
-Example input, format, and output: Dense Inputs (with defaults)
-===============================================================
+* <b>serialized</b>: A list of strings, a batch of binary serialized `Example`
+ protos.
+* <b>names</b>: A list of strings, the names of the serialized protos.
+* <b>sparse_keys</b>: A list of string keys in the examples' features.
+ The results for these keys will be returned as `SparseTensor` objects.
+* <b>sparse_types</b>: A list of `DTypes` of the same length as `sparse_keys`.
+ Only `tf.float32` (`FloatList`), `tf.int64` (`Int64List`),
+ and `tf.string` (`BytesList`) are supported.
+* <b>dense_keys</b>: A list of string keys in the examples' features.
+ The results for these keys will be returned as `Tensor`s
+* <b>dense_types</b>: A list of DTypes of the same length as `dense_keys`.
+ Only `tf.float32` (`FloatList`), `tf.int64` (`Int64List`),
+ and `tf.string` (`BytesList`) are supported.
+* <b>dense_defaults</b>: A dict mapping string keys to `Tensor`s.
+ The keys of the dict must match the dense_keys of the feature.
+* <b>dense_shapes</b>: A list of tuples with the same length as `dense_keys`.
+ The shape of the data for each dense feature referenced by `dense_keys`.
+* <b>name</b>: A name for this operation (optional).
-Given two brain.Example input protos:
+##### Returns:
+
+ A `dict` mapping keys to `Tensor`s and `SparseTensor`s.
+
+##### Raises:
-* <b>serialized</b>: // serialized versions of the protos below
- [features: {
-
-* <b>feature</b>: { key: "weight" value: { float_list: { value: [ 1.0 ] } } }
- },
-* <b>features</b>: {
-* <b>feature</b>: { key: "label" value: { float_list: { value: [ -1.0, 0.0 ] } } }
- }]
-
-* <b>names</b>: ["input0", "input1"],
-* <b>dense_keys</b>: np.array(["label", "weight"])
-* <b>dense_defaults</b>: {
- "label": [1.0, 2.0], # float (default: vector)
- "weight": 5.0 # float (default: scalar, 5.0)
-}
-
-* <b>dense_shapes</b>: [(2,), (1,)] # age, gender, label, weight
-
-Then the expected output is a dictionary:
-{
- "label": [[1.0, 2.0], [-1.0, 0.0]],
- "weight": [[1.0], [5.0]],
-}
+* <b>ValueError</b>: If sparse and dense key sets intersect, or input lengths do not
+ match up.
- - -
### tf.parse_single_example(serialized, names=None, sparse_keys=None, sparse_types=None, dense_keys=None, dense_types=None, dense_defaults=None, dense_shapes=None, name='ParseSingleExample') <div class="md-anchor" id="parse_single_example">{#parse_single_example}</div>
-Identical to parse_example but for scalar serialized and names.
+Parses a single `Example` proto.
+
+Similar to `parse_example`, except:
+
+For dense tensors, the returned `Tensor` is identical to the output of
+`parse_example`, except there is no batch dimension, the output shape is the
+same as the shape given in `dense_shape`.
+
+For `SparseTensor`s, the first (batch) column of the indices matrix is removed
+(the indices matrix is a column vector), the values vector is unchanged, and
+the first (batch_size) entry of the shape vector is removed (it is now a
+single element vector).
+
+See also `parse_example`.
##### Args:
@@ -1264,22 +1284,12 @@
* <b>dense_types</b>: See parse_example documentation for more details.
* <b>dense_defaults</b>: See parse_example documentation for more details.
* <b>dense_shapes</b>: See parse_example documentation for more details.
-* <b>name</b>: Optional op name.
+* <b>name</b>: A name for this operation (optional).
##### Returns:
A dictionary mapping keys to Tensors and SparseTensors.
- For dense tensors, the Tensor is identical to the output of parse_example,
- except it is one less dimension (the first, batch, dimension is removed).
-
- For SparseTensors:
- The first (batch) column of the indices matrix is removed
- (it is now a column vector).
- The values vector is unchanged.
- The first (batch_size) entry of the shape vector is removed
- (it is now a single element vector).
-
##### Raises:
@@ -1632,7 +1642,7 @@
## Input pipeline <div class="md-anchor" id="AUTOGENERATED-input-pipeline">{#AUTOGENERATED-input-pipeline}</div>
TensorFlow functions for setting up an input-prefetching pipeline.
-Please see the [reading data how-to](../../how_tos/reading_data.md)
+Please see the [reading data how-to](../../how_tos/reading_data/index.md)
for context.
### Beginning of an input pipeline <div class="md-anchor" id="AUTOGENERATED-beginning-of-an-input-pipeline">{#AUTOGENERATED-beginning-of-an-input-pipeline}</div>
@@ -1822,41 +1832,45 @@
Run a list of tensors to fill a queue to create batches of examples.
-This version enqueues a different list of tensors in different threads.
-Implemented using a queue -- a QueueRunner for the queue
-is added to the current Graph's QUEUE_RUNNER collection.
+Enqueues a different list of tensors in different threads.
+Implemented using a queue -- a `QueueRunner` for the queue
+is added to the current `Graph`'s `QUEUE_RUNNER` collection.
+
+`len(tensor_list_list)` threads will be started, with thread `i` enqueuing
+the tensors from tensor_list[i]. `tensor_list[i1][j]` must match
+`tensor_list[i2][j]` in type and shape, except in the first dimension if
+`enqueue_many` is true.
+
+If `enqueue_many` is false, each `tensor_list_list[i]` is assumed to
+represent a single example. Otherwise, `tensor_list_list[i]` is assumed to
+represent a batch of examples, where the first dimension is indexed by
+example, and all members of `tensor_list_list[i]` should have the same size
+in the first dimension.
+
+If `enqueue_many` is false, then an input tensor `x` will be output as a
+tensor with shape `[batch_size] + x.shape`. If `enqueue_many` is true, the
+slices of any input tensor `x` are treated as examples, and the output tensors
+will have shape `[batch_size] + x.shape[1:]`.
+
+The `capacity` argument controls the how long the prefetching
+is allowed to grow the queues.
##### Args:
* <b>tensor_list_list</b>: A list of tuples of tensors to enqueue.
- len(tensor_list_list) threads will be started, with the i-th
- thread enqueuing the tensors from tensor_list[i].
- tensor_list[i1][j] must match tensor_list[i2][j] in type and
- shape (except in the first dimension if enqueue_many is true).
-* <b>batch_size</b>: The new batch size pulled from the queue.
-* <b>capacity</b>: Maximum number of elements in the queue, controls the
- how far ahead the prefetching allowed is allowed to get and
- memory usage.
-* <b>enqueue_many</b>: If False, each tensor_list_list[i] is assumed to
- represent a single example. If True, tensor_list_list[i] is
- assumed to represent a batch of examples, where the first
- dimension is indexed by example, and all members of
- tensor_list_list[i] should have the same size in the first
- dimension.
-* <b>shapes</b>: Optional. The shapes for each example. Defaults to the
- inferred shapes for tensor_list_list[i] (which must match, after
- leaving off the first dimension if enqueue_many is True).
+* <b>batch_size</b>: An integer. The new batch size pulled from the queue.
+* <b>capacity</b>: An integer. The maximum number of elements in the queue.
+* <b>enqueue_many</b>: Whether each tensor in `tensor_list_list` is a single
+ example.
+* <b>shapes</b>: (Optional) The shapes for each example. Defaults to the
+ inferred shapes for `tensor_list_list[i]`.
* <b>name</b>: A name for the operations (optional).
##### Returns:
A list of tensors with the same number and types as
- tensor_list_list[i]. If enqueue_many is false, then an input
- tensor with shape `[x, y, z]` will be output as a tensor with
- shape `[batch_size, x, y, z]`. If enqueue_many is True, and an
- input tensor has shape `[*, x, y, z]`, the the output will have
- shape `[batch_size, x, y, z]`.
+ `tensor_list_list[i]`.
- - -
@@ -1933,15 +1947,15 @@
* <b>min_after_dequeue</b>: Minimum number elements in the queue after a
dequeue, used to ensure a level of mixing of elements.
* <b>seed</b>: Seed for the random shuffling within the queue.
-* <b>enqueue_many</b>: If False, each tensor_list_list[i] is assumed to
- represent a single example. If True, tensor_list_list[i] is
+* <b>enqueue_many</b>: If `False`, each tensor_list_list[i] is assumed to
+ represent a single example. If `True`, tensor_list_list[i] is
assumed to represent a batch of examples, where the first
dimension is indexed by example, and all members of
tensor_list_list[i] should have the same size in the first
dimension.
* <b>shapes</b>: Optional. The shapes for each example. Defaults to the
- inferred shapes for tensor_list_list[i] (which must match, after
- leaving off the first dimension if enqueue_many is True).
+ inferred shapes for `tensor_list_list[i]` (which must match, after
+ leaving off the first dimension if enqueue_many is `True`).
* <b>name</b>: A name for the operations (optional).
##### Returns:
diff --git a/tensorflow/g3doc/api_docs/python/math_ops.md b/tensorflow/g3doc/api_docs/python/math_ops.md
index fb93c38..53f7c59 100644
--- a/tensorflow/g3doc/api_docs/python/math_ops.md
+++ b/tensorflow/g3doc/api_docs/python/math_ops.md
@@ -1,6 +1,10 @@
<!-- This file is machine generated: DO NOT EDIT! -->
# Math
+
+Note: Functions taking `Tensor` arguments can also take anything
+accepted by [`tf.convert_to_tensor`](framework.md#convert_to_tensor).
+
<!-- TOC-BEGIN This section is generated by neural network: DO NOT EDIT! -->
## Contents
* [Arithmetic Operators](#AUTOGENERATED-arithmetic-operators)
diff --git a/tensorflow/g3doc/api_docs/python/nn.md b/tensorflow/g3doc/api_docs/python/nn.md
index 91fab34..50c460b 100644
--- a/tensorflow/g3doc/api_docs/python/nn.md
+++ b/tensorflow/g3doc/api_docs/python/nn.md
@@ -1,6 +1,10 @@
<!-- This file is machine generated: DO NOT EDIT! -->
# Neural Network
+
+Note: Functions taking `Tensor` arguments can also take anything
+accepted by [`tf.convert_to_tensor`](framework.md#convert_to_tensor).
+
<!-- TOC-BEGIN This section is generated by neural network: DO NOT EDIT! -->
## Contents
* [Activation Functions](#AUTOGENERATED-activation-functions)
@@ -899,7 +903,7 @@
(called candidates) for each batch of training examples.
See our [Candidate Sampling Algorithms Reference]
-(http://www.tensorflow.org/extras/candidate_sampling.pdf)
+(../../extras/candidate_sampling.pdf)
### Sampled Loss Functions <div class="md-anchor" id="AUTOGENERATED-sampled-loss-functions">{#AUTOGENERATED-sampled-loss-functions}</div>
diff --git a/tensorflow/g3doc/api_docs/python/sparse_ops.md b/tensorflow/g3doc/api_docs/python/sparse_ops.md
index 7e9ab07..1d30f81 100644
--- a/tensorflow/g3doc/api_docs/python/sparse_ops.md
+++ b/tensorflow/g3doc/api_docs/python/sparse_ops.md
@@ -1,16 +1,20 @@
<!-- This file is machine generated: DO NOT EDIT! -->
# Sparse Tensors
+
+Note: Functions taking `Tensor` arguments can also take anything
+accepted by [`tf.convert_to_tensor`](framework.md#convert_to_tensor).
+
<!-- TOC-BEGIN This section is generated by neural network: DO NOT EDIT! -->
## Contents
-* [Sparse Tensor Representation.](#AUTOGENERATED-sparse-tensor-representation.)
+* [Sparse Tensor Representation](#AUTOGENERATED-sparse-tensor-representation)
* [class tf.SparseTensor](#SparseTensor)
* [class tf.SparseTensorValue](#SparseTensorValue)
-* [Sparse to Dense Conversion.](#AUTOGENERATED-sparse-to-dense-conversion.)
+* [Sparse to Dense Conversion](#AUTOGENERATED-sparse-to-dense-conversion)
* [tf.sparse_to_dense(sparse_indices, output_shape, sparse_values, default_value, name=None)](#sparse_to_dense)
* [tf.sparse_tensor_to_dense(sp_input, default_value, name=None)](#sparse_tensor_to_dense)
* [tf.sparse_to_indicator(sp_input, vocab_size, name=None)](#sparse_to_indicator)
-* [Manipulation.](#AUTOGENERATED-manipulation.)
+* [Manipulation](#AUTOGENERATED-manipulation)
* [tf.sparse_concat(concat_dim, sp_inputs, name=None)](#sparse_concat)
* [tf.sparse_reorder(sp_input, name=None)](#sparse_reorder)
* [tf.sparse_retain(sp_input, to_retain)](#sparse_retain)
@@ -19,7 +23,7 @@
<!-- TOC-END This section was generated by neural network, THANKS FOR READING! -->
-## Sparse Tensor Representation. <div class="md-anchor" id="AUTOGENERATED-sparse-tensor-representation.">{#AUTOGENERATED-sparse-tensor-representation.}</div>
+## Sparse Tensor Representation <div class="md-anchor" id="AUTOGENERATED-sparse-tensor-representation">{#AUTOGENERATED-sparse-tensor-representation}</div>
Tensorflow supports a `SparseTensor` representation for data that is sparse
in multiple dimensions. Contrast this representation with `IndexedSlices`,
@@ -157,7 +161,7 @@
-## Sparse to Dense Conversion. <div class="md-anchor" id="AUTOGENERATED-sparse-to-dense-conversion.">{#AUTOGENERATED-sparse-to-dense-conversion.}</div>
+## Sparse to Dense Conversion <div class="md-anchor" id="AUTOGENERATED-sparse-to-dense-conversion">{#AUTOGENERATED-sparse-to-dense-conversion}</div>
- - -
@@ -296,7 +300,7 @@
-## Manipulation. <div class="md-anchor" id="AUTOGENERATED-manipulation.">{#AUTOGENERATED-manipulation.}</div>
+## Manipulation <div class="md-anchor" id="AUTOGENERATED-manipulation">{#AUTOGENERATED-manipulation}</div>
- - -
diff --git a/tensorflow/g3doc/api_docs/python/state_ops.md b/tensorflow/g3doc/api_docs/python/state_ops.md
index 70d9121..25bbe55 100644
--- a/tensorflow/g3doc/api_docs/python/state_ops.md
+++ b/tensorflow/g3doc/api_docs/python/state_ops.md
@@ -1,6 +1,10 @@
<!-- This file is machine generated: DO NOT EDIT! -->
# Variables
+
+Note: Functions taking `Tensor` arguments can also take anything
+accepted by [`tf.convert_to_tensor`](framework.md#convert_to_tensor).
+
<!-- TOC-BEGIN This section is generated by neural network: DO NOT EDIT! -->
## Contents
* [Variables](#AUTOGENERATED-variables)
@@ -11,7 +15,7 @@
* [tf.initialize_all_variables()](#initialize_all_variables)
* [tf.initialize_variables(var_list, name='init')](#initialize_variables)
* [tf.assert_variables_initialized(var_list=None)](#assert_variables_initialized)
-* [Saving and Restoring Variables.](#AUTOGENERATED-saving-and-restoring-variables.)
+* [Saving and Restoring Variables](#AUTOGENERATED-saving-and-restoring-variables)
* [class tf.train.Saver](#Saver)
* [tf.train.latest_checkpoint(checkpoint_dir, latest_filename=None)](#latest_checkpoint)
* [tf.train.get_checkpoint_state(checkpoint_dir, latest_filename=None)](#get_checkpoint_state)
@@ -325,7 +329,7 @@
This convenience method requires a session where the graph containing this
variable has been launched. If no session is passed, the default session is
-used. See the [Session class](../client.md#Session) for more information on
+used. See the [Session class](client.md#Session) for more information on
launching a graph and on sessions.
```python
@@ -506,7 +510,7 @@
-## Saving and Restoring Variables. <div class="md-anchor" id="AUTOGENERATED-saving-and-restoring-variables.">{#AUTOGENERATED-saving-and-restoring-variables.}</div>
+## Saving and Restoring Variables <div class="md-anchor" id="AUTOGENERATED-saving-and-restoring-variables">{#AUTOGENERATED-saving-and-restoring-variables}</div>
- - -
diff --git a/tensorflow/g3doc/api_docs/python/train.md b/tensorflow/g3doc/api_docs/python/train.md
index 0c88968..554d256 100644
--- a/tensorflow/g3doc/api_docs/python/train.md
+++ b/tensorflow/g3doc/api_docs/python/train.md
@@ -3,7 +3,7 @@
# Training
<!-- TOC-BEGIN This section is generated by neural network: DO NOT EDIT! -->
## Contents
-* [Optimizers.](#AUTOGENERATED-optimizers.)
+* [Optimizers](#AUTOGENERATED-optimizers)
* [class tf.train.Optimizer](#Optimizer)
* [Usage](#AUTOGENERATED-usage)
* [Processing gradients before applying them.](#AUTOGENERATED-processing-gradients-before-applying-them.)
@@ -15,7 +15,7 @@
* [class tf.train.AdamOptimizer](#AdamOptimizer)
* [class tf.train.FtrlOptimizer](#FtrlOptimizer)
* [class tf.train.RMSPropOptimizer](#RMSPropOptimizer)
-* [Gradient Computation.](#AUTOGENERATED-gradient-computation.)
+* [Gradient Computation](#AUTOGENERATED-gradient-computation)
* [tf.gradients(ys, xs, grad_ys=None, name='gradients', colocate_gradients_with_ops=False, gate_gradients=False, aggregation_method=None)](#gradients)
* [class tf.AggregationMethod](#AggregationMethod)
* [tf.stop_gradient(input, name=None)](#stop_gradient)
@@ -25,26 +25,26 @@
* [tf.clip_by_average_norm(t, clip_norm, name=None)](#clip_by_average_norm)
* [tf.clip_by_global_norm(t_list, clip_norm, use_norm=None, name=None)](#clip_by_global_norm)
* [tf.global_norm(t_list, name=None)](#global_norm)
-* [Decaying the learning rate.](#AUTOGENERATED-decaying-the-learning-rate.)
+* [Decaying the learning rate](#AUTOGENERATED-decaying-the-learning-rate)
* [tf.train.exponential_decay(learning_rate, global_step, decay_steps, decay_rate, staircase=False, name=None)](#exponential_decay)
-* [Moving Averages.](#AUTOGENERATED-moving-averages.)
+* [Moving Averages](#AUTOGENERATED-moving-averages)
* [class tf.train.ExponentialMovingAverage](#ExponentialMovingAverage)
-* [Coordinator and QueueRunner.](#AUTOGENERATED-coordinator-and-queuerunner.)
+* [Coordinator and QueueRunner](#AUTOGENERATED-coordinator-and-queuerunner)
* [class tf.train.Coordinator](#Coordinator)
* [class tf.train.QueueRunner](#QueueRunner)
* [tf.train.add_queue_runner(qr, collection='queue_runners')](#add_queue_runner)
* [tf.train.start_queue_runners(sess=None, coord=None, daemon=True, start=True, collection='queue_runners')](#start_queue_runners)
-* [Summary Operations.](#AUTOGENERATED-summary-operations.)
+* [Summary Operations](#AUTOGENERATED-summary-operations)
* [tf.scalar_summary(tags, values, collections=None, name=None)](#scalar_summary)
* [tf.image_summary(tag, tensor, max_images=None, collections=None, name=None)](#image_summary)
* [tf.histogram_summary(tag, values, collections=None, name=None)](#histogram_summary)
* [tf.nn.zero_fraction(value, name=None)](#zero_fraction)
* [tf.merge_summary(inputs, collections=None, name=None)](#merge_summary)
* [tf.merge_all_summaries(key='summaries')](#merge_all_summaries)
-* [Adding Summaries to Event Files.](#AUTOGENERATED-adding-summaries-to-event-files.)
+* [Adding Summaries to Event Files](#AUTOGENERATED-adding-summaries-to-event-files)
* [class tf.train.SummaryWriter](#SummaryWriter)
* [tf.train.summary_iterator(path)](#summary_iterator)
-* [Training utilities.](#AUTOGENERATED-training-utilities.)
+* [Training utilities](#AUTOGENERATED-training-utilities)
* [tf.train.global_step(sess, global_step_tensor)](#global_step)
* [tf.train.write_graph(graph_def, logdir, name, as_text=True)](#write_graph)
@@ -53,7 +53,7 @@
This library provides a set of classes and functions that helps train models.
-## Optimizers. <div class="md-anchor" id="AUTOGENERATED-optimizers.">{#AUTOGENERATED-optimizers.}</div>
+## Optimizers <div class="md-anchor" id="AUTOGENERATED-optimizers">{#AUTOGENERATED-optimizers}</div>
The Optimizer base class provides methods to compute gradients for a loss and
apply gradients to variables. A collection of subclasses implement classic
@@ -523,7 +523,7 @@
-## Gradient Computation. <div class="md-anchor" id="AUTOGENERATED-gradient-computation.">{#AUTOGENERATED-gradient-computation.}</div>
+## Gradient Computation <div class="md-anchor" id="AUTOGENERATED-gradient-computation">{#AUTOGENERATED-gradient-computation}</div>
TensorFlow provides functions to compute the derivatives for a given
TensorFlow computation graph, adding operations to the graph. The
@@ -816,7 +816,7 @@
-## Decaying the learning rate. <div class="md-anchor" id="AUTOGENERATED-decaying-the-learning-rate.">{#AUTOGENERATED-decaying-the-learning-rate.}</div>
+## Decaying the learning rate <div class="md-anchor" id="AUTOGENERATED-decaying-the-learning-rate">{#AUTOGENERATED-decaying-the-learning-rate}</div>
- - -
### tf.train.exponential_decay(learning_rate, global_step, decay_steps, decay_rate, staircase=False, name=None) <div class="md-anchor" id="exponential_decay">{#exponential_decay}</div>
@@ -873,7 +873,7 @@
-## Moving Averages. <div class="md-anchor" id="AUTOGENERATED-moving-averages.">{#AUTOGENERATED-moving-averages.}</div>
+## Moving Averages <div class="md-anchor" id="AUTOGENERATED-moving-averages">{#AUTOGENERATED-moving-averages}</div>
Some training algorithms, such as GradientDescent and Momentum often benefit
from maintaining a moving average of variables during optimization. Using the
@@ -1075,7 +1075,7 @@
-## Coordinator and QueueRunner. <div class="md-anchor" id="AUTOGENERATED-coordinator-and-queuerunner.">{#AUTOGENERATED-coordinator-and-queuerunner.}</div>
+## Coordinator and QueueRunner <div class="md-anchor" id="AUTOGENERATED-coordinator-and-queuerunner">{#AUTOGENERATED-coordinator-and-queuerunner}</div>
See [Threading and Queues](../../how_tos/threading_and_queues/index.md)
for how to use threads and queues. For documentation on the Queue API,
@@ -1399,17 +1399,21 @@
-## Summary Operations. <div class="md-anchor" id="AUTOGENERATED-summary-operations.">{#AUTOGENERATED-summary-operations.}</div>
+## Summary Operations <div class="md-anchor" id="AUTOGENERATED-summary-operations">{#AUTOGENERATED-summary-operations}</div>
The following ops output
[`Summary`](https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/core/framework/summary.proto)
protocol buffers as serialized string tensors.
-You can fetch the output of a summary op in a session, and pass it to a
-[SummaryWriter](train.md#SummaryWriter) to append it to an event file. You can
-then use TensorBoard to visualize the contents of the event files. See
-[TensorBoard and Summaries](../../how_tos/summaries_and_tensorboard/index.md)
-for more details.
+You can fetch the output of a summary op in a session, and pass it to
+a [SummaryWriter](train.md#SummaryWriter) to append it to an event
+file. Event files contain
+[`Event`](https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/core/util/event.proto)
+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](../../how_tos/summaries_and_tensorboard/index.md) for more
+details.
- - -
@@ -1587,7 +1591,7 @@
-## Adding Summaries to Event Files. <div class="md-anchor" id="AUTOGENERATED-adding-summaries-to-event-files.">{#AUTOGENERATED-adding-summaries-to-event-files.}</div>
+## Adding Summaries to Event Files <div class="md-anchor" id="AUTOGENERATED-adding-summaries-to-event-files">{#AUTOGENERATED-adding-summaries-to-event-files}</div>
See [Summaries and
TensorBoard](../../how_tos/summaries_and_tensorboard/index.md) for an
@@ -1768,7 +1772,7 @@
-## Training utilities. <div class="md-anchor" id="AUTOGENERATED-training-utilities.">{#AUTOGENERATED-training-utilities.}</div>
+## Training utilities <div class="md-anchor" id="AUTOGENERATED-training-utilities">{#AUTOGENERATED-training-utilities}</div>
- - -
diff --git a/tensorflow/g3doc/get_started/basic_usage.md b/tensorflow/g3doc/get_started/basic_usage.md
index 04c3334..359798d 100644
--- a/tensorflow/g3doc/get_started/basic_usage.md
+++ b/tensorflow/g3doc/get_started/basic_usage.md
@@ -77,7 +77,7 @@
op. To actually multiply the matrices, and get the result of the multiplication,
you must launch the graph in a session.
-## Launching the graph in a Session
+### Launching the graph in a session
Launching follows construction. To launch a graph, create a `Session` object.
Without arguments the session constructor launches the default graph.
@@ -102,20 +102,16 @@
# The output of the op is returned in 'result' as a numpy `ndarray` object.
result = sess.run(product)
print result
+# ==> [[ 12.]]
# Close the Session when we're done.
sess.close()
-
-
-# Stdout output ==> [[ 12.]]
```
Sessions should be closed to release resources. You can also enter a `Session`
with a "with" block. The `Session` closes automatically at the end of the
`with` block.
-
-
```python
with tf.Session() as sess:
result = sess.run([product])
@@ -150,6 +146,37 @@
See [Using GPUs](../how_tos/using_gpu/index.md) for more information about GPUs
and TensorFlow.
+## Interactive Usage
+
+The Python examples in the documentation launch the graph with a
+[`Session`](../api_docs/python/client.md#Session) and use the
+[`Session.run()`](../api_docs/python/client.md#Session.run) method to execute
+operations.
+
+For ease of use in interactive Python environments, such as
+[IPython](http://ipython.org) you can instead use the
+[`InteractiveSession`](../api_docs/python/client.md#InteractiveSession) class,
+and the [`Tensor.eval()`](../api_docs/python/framework.md#Tensor.eval) and
+[`Operation.run()`](../api_docs/python/framework.md#Operation.run) methods. This
+avoids having to keep a variable holding the session.
+
+```python
+# Enter an interactive TensorFlow Session.
+import tensorflow as tf
+sess = tf.InteractiveSession()
+
+x = tf.Variable([1.0, 2.0])
+a = tf.constant([3.0, 3.0])
+
+# Initialize 'x' using the run() method of its initializer op.
+x.initializer.run()
+
+# Add an op to subtact 'a' from 'x'. Run it and print the result
+sub = tf.sub(x, a)
+print sub.eval()
+# ==> [-2. -1.]
+```
+
## Tensors
TensorFlow programs use a tensor data structure to represent all data -- only
@@ -159,14 +186,6 @@
these concepts, see the [Rank, Shape, and Type](../resources/dims_types.md)
reference.
-
-# output:
-# [array([ 21.], dtype=float32), array([ 7.], dtype=float32)]
-
-
-
-
-
## Variables
Variables maintain state across executions of the graph. The following example
diff --git a/tensorflow/g3doc/get_started/blue_pill.jpg b/tensorflow/g3doc/get_started/blue_pill.jpg
deleted file mode 100644
index e69de29..0000000
--- a/tensorflow/g3doc/get_started/blue_pill.jpg
+++ /dev/null
diff --git a/tensorflow/g3doc/get_started/index.md b/tensorflow/g3doc/get_started/index.md
index 5b92e6e..f61fd4c 100644
--- a/tensorflow/g3doc/get_started/index.md
+++ b/tensorflow/g3doc/get_started/index.md
@@ -52,17 +52,15 @@
of MNIST, definitely take the blue pill. If you're somewhere in between, we
suggest skimming blue, then red.
-TODO(danmane): Add in creative commons attribution for these images.
-Also, make sure the sizes are precisely the same.
-
<div style="width:100%; margin:auto; margin-bottom:10px; margin-top:20px; display: flex; flex-direction: row">
<a href="../tutorials/mnist/beginners/index.md">
- <img style="flex-grow:1; flex-shrink:1;border: 1px solid black;" src="./blue_pill.jpg">
+ <img style="flex-grow:1; flex-shrink:1;border: 1px solid black;" src="./blue_pill.png">
</a>
<a href="../tutorials/mnist/pros/index.md">
- <img style="flex-grow:1; flex-shrink:1; border: 1px solid black;" src="./red_pill.jpg">
+ <img style="flex-grow:1; flex-shrink:1; border: 1px solid black;" src="./red_pill.png">
</a>
</div>
+<p style="font-size:10px;">Images licensed CC BY-SA 4.0; original by W. Carter</p>
If you're already sure you want to learn and install TensorFlow you can skip
these and charge ahead. Don't worry, you'll still get to see MNIST -- we'll
diff --git a/tensorflow/g3doc/get_started/os_setup.md b/tensorflow/g3doc/get_started/os_setup.md
index 01e6fde..f8113bc 100644
--- a/tensorflow/g3doc/get_started/os_setup.md
+++ b/tensorflow/g3doc/get_started/os_setup.md
@@ -4,10 +4,10 @@
### Ubuntu/Linux
-Make sure you have `pip` and `numpy` installed :
+Make sure you have [pip](https://pypi.python.org/pypi/pip) installed:
```sh
-$ sudo apt-get install python-pip python-numpy
+$ sudo apt-get install python-pip
```
Install TensorFlow:
@@ -22,7 +22,7 @@
### Mac OS X
-Make sure you have `pip` installed:
+Make sure you have [pip](https://pypi.python.org/pypi/pip) installed:
If using `easy_install`:
@@ -90,16 +90,16 @@
```
-## Source Installation {#source}
+## Installing from sources {#source}
### Clone the TensorFlow repository
-TODO(keveman): Supply clone command for external users.
-
```sh
-$ git clone --recurse-submodules https://YOUR_WHITELISTED_EMAIL_WITH_AT_REPLACED_BY_DOT@tensorflow.googlesource.com/tf3
+$ git clone --recurse-submodules https://tensorflow.googlesource.com/tensorflow
```
+`--recurse-submodules` is required to fetch the protobuf library that TensorFlow
+depends on.
### Installation for Linux
@@ -162,11 +162,9 @@
Please specify the location where CUDA 7.0 toolkit is installed. Refer to
README.md for more details. [default is: /usr/local/cuda]: /usr/local/cuda
-CUDA 7.0 toolkit found
Please specify the location where CUDNN 6.5 V2 library is installed. Refer to
README.md for more details. [default is: /usr/local/cuda]: /usr/local/cuda
-CUDNN 6.5 V2 library found
Setting up Cuda include
Setting up Cuda lib64
@@ -191,9 +189,6 @@
000009/000005 lambda = 2.000000 x = [0.894427 -0.447214] y = [1.788854 -0.894427]
000006/000001 lambda = 2.000000 x = [0.894427 -0.447214] y = [1.788854 -0.894427]
000009/000009 lambda = 2.000000 x = [0.894427 -0.447214] y = [1.788854 -0.894427]
-000006/000008 lambda = 2.000000 x = [0.894427 -0.447214] y = [1.788854 -0.894427]
-000009/000003 lambda = 2.000000 x = [0.894427 -0.447214] y = [1.788854 -0.894427]
-000006/000006 lambda = 2.000000 x = [0.894427 -0.447214] y = [1.788854 -0.894427]
```
Note that "--config=cuda" is needed to enable the GPU support.
@@ -231,14 +226,24 @@
Follow installation instructions [here](http://docs.scipy.org/doc/numpy/user/install.html).
-### Build and train your first TensorFlow neural net model
+
+### Create the pip package and install
```sh
-$ cd tf3
+$ bazel build -c opt //tensorflow/tools/pip_package:build_pip_package
-$ bazel build tensorflow/models/image/mnist:convolutional
+$ bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg
-$ bazel-bin/tensorflow/models/image/mnist/convolutional
+# The name of the .whl file will depend on your platform.
+$ pip install /tmp/tensorflow_pkg/tensorflow-0.5.0-cp27-none-linux_x86_64.whl
+```
+
+### Train your first TensorFlow neural net model
+
+From the root of your source tree, run:
+
+```sh
+$ python tensorflow/models/image/mnist/convolutional.py
Succesfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.
Succesfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.
Succesfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.
diff --git a/tensorflow/g3doc/get_started/red_pill.jpg b/tensorflow/g3doc/get_started/red_pill.jpg
deleted file mode 100644
index e69de29..0000000
--- a/tensorflow/g3doc/get_started/red_pill.jpg
+++ /dev/null
diff --git a/tensorflow/g3doc/how_tos/summaries_and_tensorboard/index.md b/tensorflow/g3doc/how_tos/summaries_and_tensorboard/index.md
index 18f4b42..6573187 100644
--- a/tensorflow/g3doc/how_tos/summaries_and_tensorboard/index.md
+++ b/tensorflow/g3doc/how_tos/summaries_and_tensorboard/index.md
@@ -8,8 +8,11 @@
and even additional data like images that pass through it. When TensorBoard is
fully configured, it looks like this:
-TODO(danmane): Enable a live TensorBoard
-
+ If you're on
+desktop Chrome or FF, try playing around with [this live
+TensorBoard](/tensorboard/cifar.html).
+
+
## Serializing the data
diff --git a/tensorflow/g3doc/extras/tensorflow-whitepaper2015.bib b/tensorflow/g3doc/resources/bib.md
similarity index 94%
rename from tensorflow/g3doc/extras/tensorflow-whitepaper2015.bib
rename to tensorflow/g3doc/resources/bib.md
index d04168a..94a005e 100644
--- a/tensorflow/g3doc/extras/tensorflow-whitepaper2015.bib
+++ b/tensorflow/g3doc/resources/bib.md
@@ -1,3 +1,5 @@
+# BibTex Citation
+```
@misc{tensorflow2015-whitepaper,
title={{TensorFlow}: Large-Scale Machine Learning on Heterogeneous Systems},
url={http://www.tensorflow.org/extras/tensorflow-whitepaper2015.pdf},
@@ -9,7 +11,7 @@
Eugene~Brevdo and
Zhifeng~Chen and
Craig~Citro and
- Greg~Corrado and
+ Greg~S-Corrado and
Andy~Davis and
Jeffrey~Dean and
Matthieu~Devin and
@@ -43,3 +45,4 @@
Xiaoqiang~Zheng},
year={2015},
}
+```
diff --git a/tensorflow/g3doc/resources/faq.md b/tensorflow/g3doc/resources/faq.md
index fcdc8d1..2bd485e 100644
--- a/tensorflow/g3doc/resources/faq.md
+++ b/tensorflow/g3doc/resources/faq.md
@@ -1,21 +1,28 @@
# Frequently Asked Questions
This document provides answers to some of the frequently asked questions about
-TensorFlow. If you have a question that is not covered here, please
-[get in touch](index.md).
+TensorFlow. If you have a question that is not covered here, you might find an
+answer on one of the TensorFlow [community resources](index.md).
<!-- TOC-BEGIN This section is generated by neural network: DO NOT EDIT! -->
## Contents
+ * [Building a TensorFlow graph](#AUTOGENERATED-building-a-tensorflow-graph)
+ * [Running a TensorFlow computation](#AUTOGENERATED-running-a-tensorflow-computation)
+ * [Variables](#AUTOGENERATED-variables)
+ * [Tensor shapes](#AUTOGENERATED-tensor-shapes)
+ * [TensorBoard](#AUTOGENERATED-tensorboard)
+ * [Extending TensorFlow](#AUTOGENERATED-extending-tensorflow)
+ * [Miscellaneous](#AUTOGENERATED-miscellaneous)
<!-- TOC-END This section was generated by neural network, THANKS FOR READING! -->
-#### Building a TensorFlow graph
+### Building a TensorFlow graph <div class="md-anchor" id="AUTOGENERATED-building-a-tensorflow-graph">{#AUTOGENERATED-building-a-tensorflow-graph}</div>
See also the
[API documentation on building graphs](../api_docs/python/framework.md).
-##### Why does `c = tf.matmul(a, b)` not execute the matrix multiplication immediately?
+#### Why does `c = tf.matmul(a, b)` not execute the matrix multiplication immediately?
In the TensorFlow Python API, `a`, `b`, and `c` are
[`Tensor`](../api_docs/python/framework.md#Tensor) objects. A `Tensor` object is
@@ -28,12 +35,12 @@
whole computation much more efficiently than executing the operations
one-by-one.
-##### How are devices named?
+#### How are devices named?
The supported device names are `"/device:CPU:0"` (or `"/cpu:0"`) for the CPU
device, and `"/device:GPU:i"` (or `"/gpu:i"`) for the *i*th GPU device.
-##### How do I place operations on a particular device?
+#### How do I place operations on a particular device?
To place a group of operations on a device, create them within a
[`with tf.device(name):`](../api_docs/python/framework.md#device) context. See
@@ -43,17 +50,17 @@
[CIFAR-10 tutorial](../tutorials/deep_cnn/index.md) for an example model that
uses multiple GPUs.
-##### What are the different types of tensors that are available?
+#### What are the different types of tensors that are available?
TensorFlow supports a variety of different data types and tensor shapes. See the
[ranks, shapes, and types reference](dims_types.md) for more details.
-#### Running a TensorFlow computation
+### Running a TensorFlow computation <div class="md-anchor" id="AUTOGENERATED-running-a-tensorflow-computation">{#AUTOGENERATED-running-a-tensorflow-computation}</div>
See also the
[API documentation on running graphs](../api_docs/python/client.md).
-##### What's the deal with feeding and placeholders?
+#### What's the deal with feeding and placeholders?
Feeding is a mechanism in the TensorFlow Session API that allows you to
substitute different values for one or more tensors at run time. The `feed_dict`
@@ -69,7 +76,7 @@
example of how placeholders and feeding can be used to provide the training data
for a neural network.
-##### What is the difference between `Session.run()` and `Tensor.eval()`?
+#### What is the difference between `Session.run()` and `Tensor.eval()`?
If `t` is a [`Tensor`](../api_docs/python/framework.md#Tensor) object,
[`t.eval()`](../api_docs/python/framework.md#Tensor.eval) is shorthand for
@@ -96,7 +103,7 @@
simple use cases (like unit tests); if your code deals with multiple graphs and
sessions, it may be more straightforward to explicit calls to `Session.run()`.
-##### Do Sessions have a lifetime? What about intermediate tensors?
+#### Do Sessions have a lifetime? What about intermediate tensors?
Sessions can own resources, such
[variables](../api_docs/python/state_ops.md#Variable),
@@ -110,13 +117,13 @@
[`Session.run()`](../api_docs/python/client.md) will be freed at or before the
end of the call.
-##### Can I run distributed training on multiple computers?
+#### Can I run distributed training on multiple computers?
The initial open-source release of TensorFlow supports multiple devices (CPUs
and GPUs) in a single computer. We are working on a distributed version as well:
if you are interested, please let us know so we can prioritize accordingly.
-##### Does the runtime parallelize parts of graph execution?
+#### Does the runtime parallelize parts of graph execution?
The TensorFlow runtime parallelizes graph execution across many different
dimensions:
@@ -131,7 +138,7 @@
enables the runtime to get higher throughput, if a single step does not use
all of the resources in your computer.
-##### Which client languages are supported in TensorFlow?
+#### Which client languages are supported in TensorFlow?
TensorFlow is designed to support multiple client languages. Currently, the
best-supported client language is [Python](../api_docs/python/index.md). The
@@ -145,7 +152,7 @@
that makes it easy to build a client in many different languages. We invite
contributions of new language bindings.
-##### Does TensorFlow make use of all the devices (GPUs and CPUs) available on my machine?
+#### Does TensorFlow make use of all the devices (GPUs and CPUs) available on my machine?
TensorFlow supports multiple GPUs and CPUs. See the how-to documentation on
[using GPUs with TensorFlow](../how_tos/using_gpu/index.md) for details of how
@@ -156,10 +163,10 @@
Note that TensorFlow only uses GPU devices with a compute capability greater
than 3.5.
-##### Why does `Session.run()` hang when using a reader or a queue?
+#### Why does `Session.run()` hang when using a reader or a queue?
-The [reader](../api_docs/io_ops.md#ReaderBase) and
-[queue](../api_docs/io_ops.md#QueueBase) classes provide special operations that
+The [reader](../api_docs/python/io_ops.md#ReaderBase) and
+[queue](../api_docs/python/io_ops.md#QueueBase) classes provide special operations that
can *block* until input (or free space in a bounded queue) becomes
available. These operations allow you to build sophisticated
[input pipelines](../how_tos/reading_data/index.md), at the cost of making the
@@ -168,20 +175,20 @@
[using `QueueRunner` objects to drive queues and readers](../how_tos/reading_data/index.md#QueueRunners)
for more information on how to use them.
-#### Variables
+### Variables <div class="md-anchor" id="AUTOGENERATED-variables">{#AUTOGENERATED-variables}</div>
See also the how-to documentation on [variables](../how_tos/variables/index.md)
and [variable scopes](../how_tos/variable_scope/index.md), and
[the API documentation for variables](../api_docs/python/state_ops.md).
-##### What is the lifetime of a variable?
+#### What is the lifetime of a variable?
A variable is created when you first run the
[`tf.Variable.initializer`](../api_docs/python/state_ops.md#Variable.initializer)
operation for that variable in a session. It is destroyed when that
[`session is closed`](../api_docs/python/client.md#Session.close).
-##### How do variables behave when they are concurrently accessed?
+#### How do variables behave when they are concurrently accessed?
Variables allow concurrent read and write operations. The value read from a
variable may change it is concurrently updated. By default, concurrent assigment
@@ -189,12 +196,12 @@
a lock when assigning to a variable, pass `use_locking=True` to
[`Variable.assign()`](../api_docs/python/state_ops.md#Variable.assign).
-#### Tensor shapes
+### Tensor shapes <div class="md-anchor" id="AUTOGENERATED-tensor-shapes">{#AUTOGENERATED-tensor-shapes}</div>
See also the
[`TensorShape` API documentation](../api_docs/python/framework.md#TensorShape).
-##### How can I determine the shape of a tensor in Python?
+#### How can I determine the shape of a tensor in Python?
In TensorFlow, a tensor has both a static (inferred) shape and a dynamic (true)
shape. The static shape can be read using the
@@ -205,7 +212,7 @@
shape is not fully defined, the dynamic shape of a `Tensor` `t` can be
determined by evaluating [`tf.shape(t)`](../api_docs/python/array_ops.md#shape).
-##### What is the difference between `x.set_shape()` and `x = tf.reshape(x)`?
+#### What is the difference between `x.set_shape()` and `x = tf.reshape(x)`?
The [`tf.Tensor.set_shape()`](../api_docs/python/framework.md) method updates
the static shape of a `Tensor` object, and it is typically used to provide
@@ -215,7 +222,7 @@
The [`tf.reshape()`](../api_docs/python/array_ops.md#reshape) operation creates
a new tensor with a different dynamic shape.
-##### How do I build a graph that works with variable batch sizes?
+#### How do I build a graph that works with variable batch sizes?
It is often useful to build a graph that works with variable batch sizes, for
example so that the same code can be used for (mini-)batch training, and
@@ -241,31 +248,31 @@
[`tf.placeholder(..., shape=[None, ...])`](../api_docs/python/io_ops.md#placeholder). The
`None` element of the shape corresponds to a variable-sized dimension.
-#### TensorBoard
+### TensorBoard <div class="md-anchor" id="AUTOGENERATED-tensorboard">{#AUTOGENERATED-tensorboard}</div>
See also the
[how-to documentation on TensorBoard](../how_tos/graph_viz/index.md).
-##### What is the simplest way to send data to tensorboard? # TODO(danmane)
+#### What is the simplest way to send data to tensorboard? # TODO(danmane)
Add summary_ops to your TensorFlow graph, and use a SummaryWriter to write all
of these summaries to a log directory. Then, startup TensorBoard using
<SOME_COMMAND> and pass the --logdir flag so that it points to your
log directory. For more details, see <YET_UNWRITTEN_TENSORBOARD_TUTORIAL>.
-#### Extending TensorFlow
+### Extending TensorFlow <div class="md-anchor" id="AUTOGENERATED-extending-tensorflow">{#AUTOGENERATED-extending-tensorflow}</div>
See also the how-to documentation for
[adding a new operation to TensorFlow](../how_tos/adding_an_op/index.md).
-##### My data is in a custom format. How do I read it using TensorFlow?
+#### My data is in a custom format. How do I read it using TensorFlow?
There are two main options for dealing with data in a custom format.
The easier option is to write parsing code in Python that transforms the data
-into a numpy array, then feed a
-[tf.placeholder()](../api_docs/python/io_ops.md#placeholder) a tensor with that
-data. See the documentation on
+into a numpy array, then feed a [`tf.placeholder()`]
+(../api_docs/python/io_ops.md#placeholder) a tensor with that data. See the
+documentation on
[using placeholders for input](../how_tos/reading_data/index.md#Feeding) for
more details. This approach is easy to get up and running, but the parsing can
be a performance bottleneck.
@@ -276,7 +283,7 @@
[guide to handling new data formats](../how_tos/new_data_formats/index.md) has
more information about the steps for doing this.
-##### How do I define an operation that takes a variable number of inputs?
+#### How do I define an operation that takes a variable number of inputs?
The TensorFlow op registration mechanism allows you to define inputs that are a
single tensor, a list of tensors with the same type (for example when adding
@@ -286,15 +293,15 @@
[adding an op with a list of inputs or outputs](../how_tos/adding_an_op/index.md#list-input-output)
for more details of how to define these different input types.
-#### Miscellaneous
+### Miscellaneous <div class="md-anchor" id="AUTOGENERATED-miscellaneous">{#AUTOGENERATED-miscellaneous}</div>
-##### Does TensorFlow work with Python 3?
+#### Does TensorFlow work with Python 3?
We have only tested TensorFlow using Python 2.7. We are aware of some changes
that will be required for Python 3 compatibility, and welcome contributions
towards this effort.
-##### What is TensorFlow's coding style convention?
+#### What is TensorFlow's coding style convention?
The TensorFlow Python API adheres to the
[PEP8](https://www.python.org/dev/peps/pep-0008/) conventions.<sup>*</sup> In
diff --git a/tensorflow/g3doc/resources/glossary.md b/tensorflow/g3doc/resources/glossary.md
index ab1fc4e..2e78239 100644
--- a/tensorflow/g3doc/resources/glossary.md
+++ b/tensorflow/g3doc/resources/glossary.md
@@ -1,5 +1,7 @@
# Glossary
+TODO(someone): Fix several broken links in Glossary
+
**Broadcasting operation**
An operation that uses [numpy-style broadcasting](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
diff --git a/tensorflow/g3doc/resources/index.md b/tensorflow/g3doc/resources/index.md
index c9b88f4..5e279e4 100644
--- a/tensorflow/g3doc/resources/index.md
+++ b/tensorflow/g3doc/resources/index.md
@@ -12,25 +12,33 @@
If you use TensorFlow in your research and would like to cite the TensorFlow
system, we suggest you cite the paper above. You can use this [BibTeX
-entry](../extras/tensorflow-whitepaper2015.bib). As the project progresses, we
+entry](bib.md). As the project progresses, we
may update the suggested citation with new papers.
## Community
-TODO(rajatmonga): Write this!
+### Discuss
-* NO - google group
-* YES, ASAP - internal support mailing list
-* YES, ASAP - stack overflow presence
-* SOON - slack
+* GitHub: <https://github.com/tensorflow/tensorflow>
+* Stack Overflow: <https://stackoverflow.com/questions/tagged/tensorflow>
+* [TensorFlow discuss mailing list](
+ https://groups.google.com/forum/#!forum/tensorflow-discuss)
+### Report Issues
+* [TensorFlow issues](https://github.com/tensorflow/tensorflow/issues)
+### Development
+
+* If you are interested in contributing to TensorFlow please
+ [review the contributing guide](
+ https://github.com/tensorflow/tensorflow/blob/master/CONTRIBUTING.md).
<div class='sections-order' style="display: none;">
<!--
+<!-- bib.md -->
<!-- uses.md -->
<!-- faq.md -->
<!-- glossary.md -->
diff --git a/tensorflow/g3doc/resources/uses.md b/tensorflow/g3doc/resources/uses.md
index ac42b1f..f73d4e9 100644
--- a/tensorflow/g3doc/resources/uses.md
+++ b/tensorflow/g3doc/resources/uses.md
@@ -36,7 +36,3 @@
* **Description**: On-device computer vision model to do optical character recoignition to enable real-time translation.
* **More info**: [Google Research blog post](http://googleresearch.blogspot.com/2015/07/how-google-translate-squeezes-deep.html)
}
-
-* TODO(opensource): Add several other research projects
-* TODO(opensource): Pointer Sets?
-* TODO(opensource): Others
diff --git a/tensorflow/g3doc/tutorials/deep_cnn/index.md b/tensorflow/g3doc/tutorials/deep_cnn/index.md
index f40a94b..0bbba2c 100644
--- a/tensorflow/g3doc/tutorials/deep_cnn/index.md
+++ b/tensorflow/g3doc/tutorials/deep_cnn/index.md
@@ -198,7 +198,8 @@
We visualize it in TensorBoard with a [scalar_summary](../../api_docs/python/train.md?#scalar_summary):
-[](#TODO(migmigmig)#TODO(danmane))
+
+###### [View this TensorBoard live! (Chrome/FF)](/tensorboard/cifar.html)
We train the model using standard
[gradient descent](https://en.wikipedia.org/wiki/Gradient_descent)
@@ -207,7 +208,8 @@
[exponentially decays](../../api_docs/python/train.md#exponential_decay)
over time.
-[](#TODO(migmigmig)#TODO(danmane))
+
+###### [View this TensorBoard live! (Chrome/FF)](/tensorboard/cifar.html)
The `train()` function adds the operations needed to minimize the objective by
calculating the gradient and updating the learned variables (see
diff --git a/tensorflow/g3doc/tutorials/index.md b/tensorflow/g3doc/tutorials/index.md
index 726a5c6..470645d 100644
--- a/tensorflow/g3doc/tutorials/index.md
+++ b/tensorflow/g3doc/tutorials/index.md
@@ -90,15 +90,6 @@
[View Tutorial](mnist/download/index.md)
-## Sparse Linear Regression
-
-In many practical machine learning settings we have a large number input
-features, only very few of which are active for any given example. TensorFlow
-has great tools for learning predictive models in these settings.
-
-COMING SOON
-
-
## Visual Object Recognition
We will be releasing our state-of-the-art Inception object recognition model,
@@ -116,14 +107,6 @@
COMING SOON
-## Automated Image Captioning
-
-TODO(vinyals): Write me, three lines max.
-
-COMING SOON
-
-
-
<div class='sections-order' style="display: none;">
<!--
<!-- mnist/beginners/index.md -->
diff --git a/tensorflow/g3doc/tutorials/mnist/beginners/index.md b/tensorflow/g3doc/tutorials/mnist/beginners/index.md
index 8ccb69d..398eca5 100644
--- a/tensorflow/g3doc/tutorials/mnist/beginners/index.md
+++ b/tensorflow/g3doc/tutorials/mnist/beginners/index.md
@@ -212,19 +212,12 @@
run entirely outside Python. (Approaches like this can be seen in a few
machine learning libraries.)
-To run computations, TensorFlow needs to connect to its backend. This connection
-is called a `Session`. To use TensorFlow, we need to import it and create a
-session.
+To use TensorFlow, we need to import it.
```python
import tensorflow as tf
-sess = tf.InteractiveSession()
```
-(Using an `InteractiveSession` makes TensorFlow a bit more flexible about how
-you structure your code. In particular, it's helpful for work in interactive
-contexts like iPython.)
-
We describe these interacting operations by manipulating symbolic variables.
Let's create one:
@@ -350,11 +343,19 @@
single operation which, when run, will do a step of gradient descent training,
slightly tweaking your variables to reduce the cost.
-Now we have our model set up to train. But before we start, we need to
-initialize the variables we created:
+Now we have our model set up to train. One last thing before we launch it,
+we have to add an operation to initialize the variables we created:
```python
-tf.initialize_all_variables().run()
+init = tf.initialize_all_variables()
+```
+
+We can now launch the model in a `Session`, and run the operation that
+initializes the variables:
+
+```python
+sess = tf.Session()
+sess.run(init)
```
Let's train -- we'll run the training step 1000 times!
@@ -362,7 +363,7 @@
```python
for i in range(1000):
batch_xs, batch_ys = mnist.train.next_batch(100)
- train_step.run({x: batch_xs, y_: batch_ys})
+ sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
```
Each step of the loop, we get a "batch" of one hundred random data points from
@@ -403,7 +404,7 @@
Finally, we ask for our accuracy on our test data.
```python
-print accuracy.eval({x: mnist.test.images, y_: mnist.test.labels})
+print sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels})
```
This should be about 91%.
diff --git a/tensorflow/g3doc/tutorials/mnist/pros/index.md b/tensorflow/g3doc/tutorials/mnist/pros/index.md
index 1769671..cb02925 100644
--- a/tensorflow/g3doc/tutorials/mnist/pros/index.md
+++ b/tensorflow/g3doc/tutorials/mnist/pros/index.md
@@ -32,18 +32,14 @@
It also provides a function for iterating through data minibatches, which we
will use below.
-### Start TensorFlow Session
+### Start TensorFlow InteractiveSession
Tensorflow relies on a highly efficient C++ backend to do its computation. The
-connection to this backend is called a session. We will need to create a session
-before we can do any computation.
+connection to this backend is called a session. The common usage for TensorFlow
+programs is to first create a graph and then launch it in a session.
-```python
-import tensorflow as tf
-sess = tf.InteractiveSession()
-```
-
-Using an `InteractiveSession` makes TensorFlow more flexible about how you
+Here we instead use the convenience `InteractiveSession` class, which
+makes TensorFlow more flexible about how you
structure your code.
It allows you to interleave operations which build a
[computation graph](../../../get_started/basic_usage.md#the-computation-graph)
@@ -54,6 +50,11 @@
the entire computation graph before starting a session and [launching the
graph](../../../get_started/basic_usage.md#launching-the-graph-in-a-session).
+```python
+import tensorflow as tf
+sess = tf.InteractiveSession()
+```
+
#### Computation Graph
To do efficient numerical computing in Python, we typically use libraries like
diff --git a/tensorflow/g3doc/tutorials/word2vec/index.md b/tensorflow/g3doc/tutorials/word2vec/index.md
index 8779f33..832c7c1 100644
--- a/tensorflow/g3doc/tutorials/word2vec/index.md
+++ b/tensorflow/g3doc/tutorials/word2vec/index.md
@@ -373,14 +373,14 @@
compromised speed because we use Python for reading and feeding data items --
each of which require very little work on the TensorFlow back-end. If you find
your model is seriously bottlenecked on input data, you may want to implement a
-custom data reader for your problem, as described in [New Data
-Formats](../how_tos/new_data_formats/index.md). For the case of Skip-Gram
+custom data reader for your problem, as described in
+[New Data Formats](../../how_tos/new_data_formats/index.md). For the case of Skip-Gram
modeling, we've actually already done this for you as an example in
[tensorflow/models/embedding/word2vec.py](https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/models/embedding/word2vec.py).
If your model is no longer I/O bound but you want still more performance, you
can take things further by writing your own TensorFlow Ops, as described in
-[Adding a New Op](../how_tos/adding_an_op/index.md). Again we've provided an
+[Adding a New Op](../../how_tos/adding_an_op/index.md). Again we've provided an
example of this for the Skip-Gram case
[tensorflow/models/embedding/word2vec_optimized.py](https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/models/embedding/word2vec_optimized.py).
Feel free to benchmark these against each other to measure performance
diff --git a/tensorflow/g3doc/tutorials/word2vec/word2vec_basic.py b/tensorflow/g3doc/tutorials/word2vec/word2vec_basic.py
index 0a98157..632ce1f 100644
--- a/tensorflow/g3doc/tutorials/word2vec/word2vec_basic.py
+++ b/tensorflow/g3doc/tutorials/word2vec/word2vec_basic.py
@@ -1,3 +1,5 @@
+import tensorflow.python.platform
+
import collections
import math
import numpy as np
@@ -216,4 +218,3 @@
except ImportError:
print "Please install sklearn and matplotlib to visualize embeddings."
-
diff --git a/tensorflow/models/embedding/BUILD b/tensorflow/models/embedding/BUILD
index 0fb164b..f8f7e7b 100644
--- a/tensorflow/models/embedding/BUILD
+++ b/tensorflow/models/embedding/BUILD
@@ -31,6 +31,26 @@
],
)
+py_test(
+ name = "word2vec_test",
+ size = "small",
+ srcs = ["word2vec_test.py"],
+ deps = [
+ ":word2vec",
+ "//tensorflow:tensorflow_py",
+ ],
+)
+
+py_test(
+ name = "word2vec_optimized_test",
+ size = "small",
+ srcs = ["word2vec_optimized_test.py"],
+ deps = [
+ ":word2vec_optimized",
+ "//tensorflow:tensorflow_py",
+ ],
+)
+
cc_library(
name = "word2vec_ops",
srcs = [
diff --git a/tensorflow/models/embedding/word2vec.py b/tensorflow/models/embedding/word2vec.py
index 4ebf3d6..a31de44 100644
--- a/tensorflow/models/embedding/word2vec.py
+++ b/tensorflow/models/embedding/word2vec.py
@@ -402,7 +402,7 @@
if now - last_checkpoint_time > opts.checkpoint_interval:
self.saver.save(self._session,
opts.save_path + "model",
- global_step=step)
+ global_step=step.astype(int))
last_checkpoint_time = now
if epoch != initial_epoch:
break
@@ -482,6 +482,9 @@
def main(_):
"""Train a word2vec model."""
+ if not FLAGS.train_data or not FLAGS.eval_data or not FLAGS.save_path:
+ print "--train_data --eval_data and --save_path must be specified."
+ sys.exit(1)
opts = Options()
with tf.Graph().as_default(), tf.Session() as session:
model = Word2Vec(opts, session)
diff --git a/tensorflow/models/embedding/word2vec_optimized.py b/tensorflow/models/embedding/word2vec_optimized.py
index 23e7645..4d69601 100644
--- a/tensorflow/models/embedding/word2vec_optimized.py
+++ b/tensorflow/models/embedding/word2vec_optimized.py
@@ -386,6 +386,9 @@
def main(_):
"""Train a word2vec model."""
+ if not FLAGS.train_data or not FLAGS.eval_data or not FLAGS.save_path:
+ print "--train_data --eval_data and --save_path must be specified."
+ sys.exit(1)
opts = Options()
with tf.Graph().as_default(), tf.Session() as session:
model = Word2Vec(opts, session)
diff --git a/tensorflow/models/embedding/word2vec_optimized_test.py b/tensorflow/models/embedding/word2vec_optimized_test.py
new file mode 100644
index 0000000..bc109d5
--- /dev/null
+++ b/tensorflow/models/embedding/word2vec_optimized_test.py
@@ -0,0 +1,44 @@
+"""Tests for word2vec_optimized module."""
+
+import os
+
+import tensorflow.python.platform
+import tensorflow as tf
+
+from tensorflow.models.embedding import word2vec_optimized as word2vec_optimized
+
+flags = tf.app.flags
+
+FLAGS = flags.FLAGS
+
+
+class Word2VecTest(tf.test.TestCase):
+
+ def setUp(self):
+ FLAGS.train_data = os.path.join(self.get_temp_dir() + "test-text.txt")
+ FLAGS.eval_data = os.path.join(self.get_temp_dir() + "eval-text.txt")
+ FLAGS.save_path = self.get_temp_dir()
+ with open(FLAGS.train_data, "w") as f:
+ f.write(
+ """alice was beginning to get very tired of sitting by her sister on
+ the bank, and of having nothing to do: once or twice she had peeped
+ into the book her sister was reading, but it had no pictures or
+ conversations in it, 'and what is the use of a book,' thought alice
+ 'without pictures or conversations?' So she was considering in her own
+ mind (as well as she could, for the hot day made her feel very sleepy
+ and stupid), whether the pleasure of making a daisy-chain would be
+ worth the trouble of getting up and picking the daisies, when suddenly
+ a White rabbit with pink eyes ran close by her.\n""")
+ with open(FLAGS.eval_data, "w") as f:
+ f.write("alice she rabbit once\n")
+
+ def testWord2VecOptimized(self):
+ FLAGS.batch_size = 5
+ FLAGS.num_neg_samples = 10
+ FLAGS.epochs_to_train = 1
+ FLAGS.min_count = 0
+ word2vec_optimized.main([])
+
+
+if __name__ == "__main__":
+ tf.test.main()
diff --git a/tensorflow/models/embedding/word2vec_test.py b/tensorflow/models/embedding/word2vec_test.py
new file mode 100644
index 0000000..62a033d
--- /dev/null
+++ b/tensorflow/models/embedding/word2vec_test.py
@@ -0,0 +1,44 @@
+"""Tests for word2vec module."""
+
+import os
+
+import tensorflow.python.platform
+import tensorflow as tf
+
+from tensorflow.models.embedding import word2vec as word2vec
+
+flags = tf.app.flags
+
+FLAGS = flags.FLAGS
+
+
+class Word2VecTest(tf.test.TestCase):
+
+ def setUp(self):
+ FLAGS.train_data = os.path.join(self.get_temp_dir() + "test-text.txt")
+ FLAGS.eval_data = os.path.join(self.get_temp_dir() + "eval-text.txt")
+ FLAGS.save_path = self.get_temp_dir()
+ with open(FLAGS.train_data, "w") as f:
+ f.write(
+ """alice was beginning to get very tired of sitting by her sister on
+ the bank, and of having nothing to do: once or twice she had peeped
+ into the book her sister was reading, but it had no pictures or
+ conversations in it, 'and what is the use of a book,' thought alice
+ 'without pictures or conversations?' So she was considering in her own
+ mind (as well as she could, for the hot day made her feel very sleepy
+ and stupid), whether the pleasure of making a daisy-chain would be
+ worth the trouble of getting up and picking the daisies, when suddenly
+ a White rabbit with pink eyes ran close by her.\n""")
+ with open(FLAGS.eval_data, "w") as f:
+ f.write("alice she rabbit once\n")
+
+ def testWord2Vec(self):
+ FLAGS.batch_size = 5
+ FLAGS.num_neg_samples = 10
+ FLAGS.epochs_to_train = 1
+ FLAGS.min_count = 0
+ word2vec.main([])
+
+
+if __name__ == "__main__":
+ tf.test.main()
diff --git a/tensorflow/python/framework/device.py b/tensorflow/python/framework/device.py
index 676e5f7..b6d7256 100644
--- a/tensorflow/python/framework/device.py
+++ b/tensorflow/python/framework/device.py
@@ -90,7 +90,7 @@
for y in splits:
ly = len(y)
if y:
- # NOTE(mdevin): we use the property getters here.
+ # NOTE(touts): we use the property getters here.
if ly == 2 and y[0] == "job":
self.job = y[1]
elif ly == 2 and y[0] == "replica":
diff --git a/tensorflow/python/framework/docs.py b/tensorflow/python/framework/docs.py
index 68dbb3d..fcf269c 100644
--- a/tensorflow/python/framework/docs.py
+++ b/tensorflow/python/framework/docs.py
@@ -60,18 +60,18 @@
print >>f, ""
print >>f, "# TensorFlow Python reference documentation"
print >>f, ""
+ fullname_f = lambda name: self._members[name][0]
+ anchor_f = lambda name: _get_anchor(self._module_to_name, fullname_f(name))
+
for filename, library in self._filename_to_library_map:
- per_symbol_links = []
- for name in sorted(library.mentioned):
- if name in self._members:
- fullname, member = self._members[name]
- anchor = _get_anchor(self._module_to_name, fullname)
- prefix = "class " * inspect.isclass(member)
- per_symbol_links.append("[%s%s](%s#%s)" %
- (prefix, name, filename, anchor))
- if per_symbol_links:
- print >>f, "* <b>[%s](%s)</b>: %s" % (library.title, filename,
- ",\n ".join(per_symbol_links))
+ sorted_names = sorted(library.mentioned, key=str.lower)
+ member_names = [n for n in sorted_names if n in self._members]
+ links = ["[`%s`](%s#%s)" % (name, filename, anchor_f(name))
+ for name in member_names]
+ if links:
+ print >>f, "* **[%s](%s)**:" % (library.title, filename)
+ for link in links:
+ print >>f, " * %s" % link
print >>f, ""
# actually include the files right here
@@ -146,7 +146,7 @@
members,
documented,
exclude_symbols=(),
- catch_all=False):
+ prefix=None):
"""Creates a new Library.
Args:
@@ -157,6 +157,7 @@
members: Dictionary mapping member name to (fullname, member).
documented: Set of documented names to update.
exclude_symbols: A list of specific symbols to exclude.
+ prefix: A string to include at the beginning of the page.
"""
self._title = title
self._module = module
@@ -166,6 +167,7 @@
documented.update(exclude_symbols)
self._documented = documented
self._mentioned = set()
+ self._prefix = prefix or ""
@property
def title(self):
@@ -400,7 +402,7 @@
# defined by the class itself (not inherited). If NO methods were
# described, describe all methods.
#
- # TODO(mdevin): when all methods have been categorized make it an error
+ # TODO(touts): when all methods have been categorized make it an error
# if some methods are not categorized.
any_method_called_out = (len(methods) != num_methods)
if any_method_called_out:
@@ -429,9 +431,11 @@
"""
print >>f, "<!-- This file is machine generated: DO NOT EDIT! -->"
print >>f, ""
- # TODO(mdevin): Do not insert these. Let the doc writer put them in
+ # TODO(touts): Do not insert these. Let the doc writer put them in
# the module docstring explicitly.
print >>f, "#", self._title
+ if self._prefix:
+ print >>f, self._prefix
print >>f, "[TOC]"
print >>f, ""
if self._module is not None:
diff --git a/tensorflow/python/framework/errors.py b/tensorflow/python/framework/errors.py
index fe8f107..b3f9a78 100644
--- a/tensorflow/python/framework/errors.py
+++ b/tensorflow/python/framework/errors.py
@@ -43,7 +43,8 @@
or `Recv` op, there will be no corresponding
[`Operation`](framework.md#Operation) object. In that case, this
will return `None`, and you should instead use the
- [`node_def`](OpError.node_def) to discover information about the op.
+ [`OpError.node_def`](#OpError.node_def) to discover information about the
+ op.
Returns:
The `Operation` that failed, or None.
@@ -293,7 +294,7 @@
For example, running a [`queue.enqueue()`](io_ops.md#QueueBase.enqueue)
operation may raise `AbortedError` if a
- [`queue.close()`](io_ops.md@QueueBase.close) operation previously ran.
+ [`queue.close()`](io_ops.md#QueueBase.close) operation previously ran.
@@__init__
"""
diff --git a/tensorflow/python/framework/framework_lib.py b/tensorflow/python/framework/framework_lib.py
index e317cfd..eacd4f5 100644
--- a/tensorflow/python/framework/framework_lib.py
+++ b/tensorflow/python/framework/framework_lib.py
@@ -1,5 +1,5 @@
# pylint: disable=wildcard-import,unused-import,g-bad-import-order,line-too-long
-"""Import names from the framework library.
+"""Classes and functions for building TensorFlow graphs.
## Core graph data structures
diff --git a/tensorflow/python/framework/gen_docs_combined.py b/tensorflow/python/framework/gen_docs_combined.py
index a726d88..e82c45d 100644
--- a/tensorflow/python/framework/gen_docs_combined.py
+++ b/tensorflow/python/framework/gen_docs_combined.py
@@ -18,6 +18,12 @@
FLAGS = tf.flags.FLAGS
+PREFIX_TEXT = """
+Note: Functions taking `Tensor` arguments can also take anything
+accepted by [`tf.convert_to_tensor`](framework.md#convert_to_tensor).
+"""
+
+
def get_module_to_name():
return {tf: 'tf',
tf.errors: 'tf.errors',
@@ -42,20 +48,24 @@
return [
# Splits of module 'tf'.
library("framework", "Building Graphs", framework_lib),
- library("constant_op", "Constants, Sequences, and Random Values"),
- library("state_ops", "Variables"),
+ library("constant_op", "Constants, Sequences, and Random Values",
+ prefix=PREFIX_TEXT),
+ library("state_ops", "Variables", prefix=PREFIX_TEXT),
library("array_ops", "Tensor Transformations",
- exclude_symbols=["list_diff"]),
+ exclude_symbols=["list_diff"], prefix=PREFIX_TEXT),
library("math_ops", "Math",
exclude_symbols=["sparse_matmul", "arg_min", "arg_max",
- "lin_space", "sparse_segment_mean_grad"]),
- library("control_flow_ops", "Control Flow"),
- library("image", "Images", tf.image, exclude_symbols=["ResizeMethod"]),
- library("sparse_ops", "Sparse Tensors"),
+ "lin_space", "sparse_segment_mean_grad"],
+ prefix=PREFIX_TEXT),
+ library("control_flow_ops", "Control Flow", prefix=PREFIX_TEXT),
+ library("image", "Images", tf.image, exclude_symbols=["ResizeMethod"],
+ prefix=PREFIX_TEXT),
+ library("sparse_ops", "Sparse Tensors", prefix=PREFIX_TEXT),
library("io_ops", "Inputs and Readers",
exclude_symbols=["LookupTableBase", "HashTable",
"initialize_all_tables",
- "string_to_hash_bucket"]),
+ "string_to_hash_bucket"],
+ prefix=PREFIX_TEXT),
library("python_io", "Data IO (Python functions)", tf.python_io),
library("nn", "Neural Network", tf.nn,
exclude_symbols=["deconv2d", "conv2d_backprop_input",
@@ -66,7 +76,8 @@
"xw_plus_b", "relu_layer", "lrn",
"batch_norm_with_global_normalization",
"batch_norm_with_global_normalization_grad",
- "all_candidate_sampler"]),
+ "all_candidate_sampler"],
+ prefix=PREFIX_TEXT),
library('client', "Running Graphs", client_lib,
exclude_symbols=["InteractiveSession"]),
library("train", "Training", tf.train,
diff --git a/tensorflow/python/framework/ops.py b/tensorflow/python/framework/ops.py
index 0b0442c..addcb1f 100644
--- a/tensorflow/python/framework/ops.py
+++ b/tensorflow/python/framework/ops.py
@@ -1604,6 +1604,10 @@
def as_graph_def(self, from_version=None):
"""Returns a serialized `GraphDef` representation of this graph.
+ The serialized `GraphDef` can be imported into another `Graph`
+ (using [`import_graph_def()`](#import_graph_def)) or used with the
+ [C++ Session API](../cc/index.md).
+
This method is thread-safe.
Args:
@@ -1612,8 +1616,7 @@
its `version` property had the given value.
Returns:
- A
- [`GraphDef`](https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/core/framework/graph.proto)
+ A [`GraphDef`](https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/core/framework/graph.proto)
protocol buffer.
"""
graph = graph_pb2.GraphDef()
@@ -2116,7 +2119,7 @@
self._names_in_use[name] = 1
return name
- # TODO(mdevin): remove
+ # TODO(touts): remove
def _plain_name(self, name):
"""Return the fully scoped 'name'.
diff --git a/tensorflow/python/framework/tensor_util.py b/tensorflow/python/framework/tensor_util.py
index 81ed54c..c4e6d27 100644
--- a/tensorflow/python/framework/tensor_util.py
+++ b/tensorflow/python/framework/tensor_util.py
@@ -39,7 +39,7 @@
fast_tensor_util.AppendUInt8ArrayToTensorProto,
types.qint32.as_numpy_dtype:
fast_tensor_util.AppendInt32ArrayToTensorProto,
- # NOTE(mdevin): Intentionally no way to feed a DT_BFLOAT16.
+ # NOTE(touts): Intentionally no way to feed a DT_BFLOAT16.
}
else:
@@ -81,7 +81,7 @@
types.qint8.as_numpy_dtype: SlowAppendIntArrayToTensorProto,
types.quint8.as_numpy_dtype: SlowAppendIntArrayToTensorProto,
types.qint32.as_numpy_dtype: SlowAppendIntArrayToTensorProto,
- # NOTE(mdevin): Intentionally no way to feed a DT_BFLOAT16.
+ # NOTE(touts): Intentionally no way to feed a DT_BFLOAT16.
}
@@ -472,7 +472,7 @@
Raises:
TypeError: if tensor is not an ops.Tensor.
"""
- # TODO(mdevin): Support Variables?
+ # TODO(touts): Support Variables?
if not isinstance(tensor, ops.Tensor):
raise TypeError("tensor is not a Tensor")
if tensor.op.type == "Const":
diff --git a/tensorflow/python/framework/types.py b/tensorflow/python/framework/types.py
index 6a8c629..ed45f1b 100644
--- a/tensorflow/python/framework/types.py
+++ b/tensorflow/python/framework/types.py
@@ -332,7 +332,7 @@
(_np_qint8, qint8),
(_np_quint8, quint8),
(_np_qint32, qint32),
- # NOTE(mdevin): Intentionally no way to feed a DT_BFLOAT16.
+ # NOTE(touts): Intentionally no way to feed a DT_BFLOAT16.
])
_TF_TO_NP = {
types_pb2.DT_FLOAT: np.float32,
@@ -341,7 +341,7 @@
types_pb2.DT_UINT8: np.uint8,
types_pb2.DT_INT16: np.int16,
types_pb2.DT_INT8: np.int8,
- # NOTE(mdevin): For strings we use np.object as it supports variable length
+ # NOTE(touts): For strings we use np.object as it supports variable length
# strings.
types_pb2.DT_STRING: np.object,
types_pb2.DT_COMPLEX64: np.complex64,
diff --git a/tensorflow/python/framework/types_test.py b/tensorflow/python/framework/types_test.py
index acd2994..d933a28 100644
--- a/tensorflow/python/framework/types_test.py
+++ b/tensorflow/python/framework/types_test.py
@@ -34,7 +34,7 @@
numpy_dtype = dtype.as_numpy_dtype
_ = np.empty((1, 1, 1, 1), dtype=numpy_dtype)
if dtype.base_dtype != types.bfloat16:
- # NOTE(mdevin): Intentionally no way to feed a DT_BFLOAT16.
+ # NOTE(touts): Intentionally no way to feed a DT_BFLOAT16.
self.assertEqual(
types.as_dtype(datatype_enum).base_dtype, types.as_dtype(numpy_dtype))
diff --git a/tensorflow/python/kernel_tests/pad_op_test.py b/tensorflow/python/kernel_tests/pad_op_test.py
index 113aeb1..cb939a3 100644
--- a/tensorflow/python/kernel_tests/pad_op_test.py
+++ b/tensorflow/python/kernel_tests/pad_op_test.py
@@ -98,7 +98,7 @@
tf.constant([-1, 0], shape=[1, 2]))
def testIntTypes(self):
- # TODO(mdevin): Figure out why the padding tests do not work on GPU
+ # TODO(touts): Figure out why the padding tests do not work on GPU
# for int types and rank > 2.
for t in [np.int32, np.int64]:
self._testPad((np.random.rand(4, 3, 3) * 100).astype(t),
diff --git a/tensorflow/python/kernel_tests/variable_ops_test.py b/tensorflow/python/kernel_tests/variable_ops_test.py
index aaa4237..6185b22 100644
--- a/tensorflow/python/kernel_tests/variable_ops_test.py
+++ b/tensorflow/python/kernel_tests/variable_ops_test.py
@@ -33,7 +33,7 @@
x = vals.astype(dtype)
tftype = _NP_TO_TF[dtype]
self.assertAllEqual(x, self._initFetch(x, tftype, use_gpu=False))
- # NOTE(mdevin): the GPU test should pass for all types, whether the
+ # NOTE(touts): the GPU test should pass for all types, whether the
# Variable op has an implementation for that type on GPU as we expect
# that Variable and Assign have GPU implementations for matching tf.
self.assertAllEqual(x, self._initFetch(x, tftype, use_gpu=True))
diff --git a/tensorflow/python/ops/control_flow_ops.py b/tensorflow/python/ops/control_flow_ops.py
index 068e3b5..2c089de 100644
--- a/tensorflow/python/ops/control_flow_ops.py
+++ b/tensorflow/python/ops/control_flow_ops.py
@@ -1192,7 +1192,7 @@
return no_op(name=name)
-# TODO(mdevin): Accept "inputs" as a list.
+# TODO(touts): Accept "inputs" as a list.
def group(*inputs, **kwargs):
"""Create an op that groups multiple operations.
@@ -1217,7 +1217,7 @@
if kwargs:
raise ValueError("Unknown keyword arguments: " + ", ".join(kwargs.keys()))
if not inputs:
- # TODO(mdevin): Would make sense to return a NoOp.
+ # TODO(touts): Would make sense to return a NoOp.
raise ValueError("No inputs provided")
with ops.op_scope(inputs, name, "group_deps") as name:
# Sorts *inputs according to their devices.
diff --git a/tensorflow/python/ops/gradients_test.py b/tensorflow/python/ops/gradients_test.py
index dac0ebb..96af01e 100644
--- a/tensorflow/python/ops/gradients_test.py
+++ b/tensorflow/python/ops/gradients_test.py
@@ -37,7 +37,7 @@
The list of operations between "from_ops" and "to_ops", sorted by
decreasing operation id. This list contains all elements of to_ops.
- TODO(mdevin): Think about returning an empty list if from_ops are not
+ TODO(touts): Think about returning an empty list if from_ops are not
reachable from to_ops. Presently it returns to_ops in that case.
"""
# List of booleans, indexed by operation id, indicating if
diff --git a/tensorflow/python/ops/image_ops.py b/tensorflow/python/ops/image_ops.py
index 1b4f4ae..89f9821 100644
--- a/tensorflow/python/ops/image_ops.py
+++ b/tensorflow/python/ops/image_ops.py
@@ -1,4 +1,5 @@
-"""## Encoding and Decoding.
+# pylint: disable=g-short-docstring-punctuation
+"""## Encoding and Decoding
TensorFlow provides Ops to decode and encode JPEG and PNG formats. Encoded
images are represented by scalar string Tensors, decoded images by 3-D uint8
@@ -17,7 +18,7 @@
@@decode_png
@@encode_png
-## Resizing.
+## Resizing
The resizing Ops accept input images as tensors of several types. They always
output resized images as float32 tensors.
@@ -51,7 +52,7 @@
@@resize_nearest_neighbor
-## Cropping.
+## Cropping
@@resize_image_with_crop_or_pad
@@ -60,7 +61,7 @@
@@random_crop
@@extract_glimpse
-## Flipping and Transposing.
+## Flipping and Transposing
@@flip_up_down
@@random_flip_up_down
@@ -70,7 +71,7 @@
@@transpose_image
-## Image Adjustments.
+## Image Adjustments
TensorFlow provides functions to adjust images in various ways: brightness,
contrast, hue, and saturation. Each adjustment can be done with predefined
diff --git a/tensorflow/python/ops/io_ops.py b/tensorflow/python/ops/io_ops.py
index 9eb3bdf..829081f 100644
--- a/tensorflow/python/ops/io_ops.py
+++ b/tensorflow/python/ops/io_ops.py
@@ -1,3 +1,4 @@
+# pylint: disable=line-too-long
"""## Placeholders
TensorFlow provides a placeholder operation that must be fed with data
@@ -26,6 +27,18 @@
@@decode_csv
@@decode_raw
+
+- - -
+
+### Example protocol buffer
+
+TensorFlow's [recommended format for training
+examples](../../how_tos/reading_data/index.md#standard-tensorflow-format)
+is serialized `Example` protocol buffers, [described
+here](https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/core/example/example.proto).
+They contain `Features`, [described
+here](https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/core/example/feature.proto).
+
@@parse_example
@@parse_single_example
@@ -49,7 +62,7 @@
## Input pipeline
TensorFlow functions for setting up an input-prefetching pipeline.
-Please see the [reading data how-to](../../how_tos/reading_data.md)
+Please see the [reading data how-to](../../how_tos/reading_data/index.md)
for context.
### Beginning of an input pipeline
diff --git a/tensorflow/python/ops/math_ops.py b/tensorflow/python/ops/math_ops.py
index d96320e..b0e548b 100644
--- a/tensorflow/python/ops/math_ops.py
+++ b/tensorflow/python/ops/math_ops.py
@@ -289,7 +289,7 @@
values_cast = cast(x.values, dtype, name=name)
return ops.SparseTensor(x.indices, values_cast, x.shape)
else:
- # TODO(mdevin): Handle what Josh said.
+ # TODO(touts): Handle what Josh said.
#
# Could return ops.convert_to_tensor(x, dtype=dtype, ...) here, but that
# allows some conversions that cast() can't do, e.g. casting numbers to
@@ -801,7 +801,7 @@
Raises:
TypeError: If 'x' is not a Tensor or an IndexedSlices object.
"""
- # TODO(mdevin): op_scope
+ # TODO(touts): op_scope
if not isinstance(x, (ops.Tensor, ops.IndexedSlices)):
raise TypeError("Not a Tensor or IndexedSlices: %s" % type(x))
if isinstance(x, ops.IndexedSlices):
diff --git a/tensorflow/python/ops/nn.py b/tensorflow/python/ops/nn.py
index 7a4dc25..8eccc63 100644
--- a/tensorflow/python/ops/nn.py
+++ b/tensorflow/python/ops/nn.py
@@ -143,7 +143,7 @@
(called candidates) for each batch of training examples.
See our [Candidate Sampling Algorithms Reference]
-(http://www.tensorflow.org/extras/candidate_sampling.pdf)
+(../../extras/candidate_sampling.pdf)
### Sampled Loss Functions
diff --git a/tensorflow/python/ops/parsing_ops.py b/tensorflow/python/ops/parsing_ops.py
index dc954a3..940c932 100644
--- a/tensorflow/python/ops/parsing_ops.py
+++ b/tensorflow/python/ops/parsing_ops.py
@@ -28,96 +28,90 @@
dense_defaults=None,
dense_shapes=None,
name="ParseExample"):
- """Parse Example protos.
+ """Parses `Example` protos.
- Args:
- serialized: string vector, a batch of binary serialized Example protos.
- names: A string vector, the names of the serialized protos.
- "names" may contain, e.g., table key (descriptive) names for the
- corresponding serialized protos. These are purely useful for debugging
- purposes, and the presence of values here has no effect on the output.
- "names" may be an empty vector, if no names are available.
- If non-empty, this vector must be the same length as "serialized".
- sparse_keys: A string list of keys in the Examples' features.
- These keys are associated with sparse values.
- sparse_types: A list of DTypes.
- This list's length must match that of sparse_keys. Currently
- parse_example supports tf.float32 (FloatList), tf.int64 (Int64List),
- and tf.string (BytesList).
- dense_keys: A string list of keys in the Examples' features.
- These keys are associated with dense values.
- dense_types: A list of DTypes.
- This list's length must match that of dense_keys. Currently
- parse_example supports tf.float32 (FloatList), tf.int64 (Int64List),
- and tf.string (BytesList).
- dense_defaults: A dict of {key:Tensor} (some may be missing).
- The keys of the dict must match the dense_keys of the feature.
- If a key is not present in this dictionary, the corresponding dense
- Feature is required in all elements of serialized.
- dense_shapes: A list of tuples.
- Entries provide the shape of data in each dense Feature in features.
- The length of dense_shapes must be the same as the length of dense_keys.
- The number of elements in the Feature corresponding to dense_key[j]
- must always have np.prod(dense_shapes[j]) entries.
- If dense_shapes[j] == (D0, D1, ..., DN) then the the shape of output
- Tensor dense_values[j] will be (|serialized|, D0, D1, ..., DN):
- The dense outputs are just the inputs row-stacked by batch.
- name: (Optional) Name of Op in the graph.
+ Parses a number of serialized [`Example`]
+ (https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/core/example/example.proto)
+ protos given in `serialized`.
- Returns:
- A dictionary mapping keys to Tensors and SparseTensors.
+ `names` may contain descriptive names for the corresponding serialized protos.
+ These may be useful for debugging purposes, but they have no effect on the
+ output. If not `None`, `names` must be the same length as `serialized`.
- The key dense_keys[j] is mapped to a tensor of type dense_types[j] and
- of shape (serialized.size(),) + dense_shapes[j] (i.e., the dense outputs are
- inputs, reshaped in row-major format and then row-stacked by batch).
+ This op parses serialized examples into a dictionary mapping keys to `Tensor`
+ and `SparseTensor` objects respectively, depending on whether the keys appear
+ in `sparse_keys` or `dense_keys`.
- The key sparse_keys[j] is mapped to a SparseTensor of type sparse_types[j].
- The SparseTensor represents a ragged matrix. Its indices are [batch, index]
- where "batch" is is the batch entry the value is from, and "index" is the
- value's index in the list of values associated with that feature
- and example. For example, if one expects a tf.float32 sparse feature "ft"
- and three serialized examples are provided:
+ The key `dense_keys[j]` is mapped to a `Tensor` of type `dense_types[j]` and
+ of shape `(serialized.size(),) + dense_shapes[j]`.
- serialized = [
- features:
- { feature: [ key: { "ft" value: float_list: { value: [1.0, 2.0] } } ] },
- features:
- { feature: [] },
- features:
- { feature: [ key: { "ft" value: float_list: { value: [3.0] } } ] }
- ]
+ `dense_defaults` provides defaults for values referenced using `dense_keys`.
+ If a key is not present in this dictionary, the corresponding dense `Feature`
+ is required in all elements of `serialized`.
- then the output will look like:
+ `dense_shapes[j]` provides the shape of each `Feature` entry referenced by
+ `dense_keys[j]`. The number of elements in the `Feature` corresponding to
+ `dense_key[j]` must always have `np.prod(dense_shapes[j])` entries. The
+ returned `Tensor` for `dense_key[j]` has shape `[N] + dense_shape[j]`, where
+ `N` is the number of `Example`s in `serialized`.
- {"ft": SparseTensor(indices=[[0, 0], [0, 1], [2, 0]],
- values=[1.0, 2.0, 3.0],
- shape=(3, 2)) }
+ The key `sparse_keys[j]` is mapped to a `SparseTensor` of type
+ `sparse_types[j]`. The `SparseTensor` represents a ragged matrix.
+ Its indices are `[batch, index]` where `batch` is the batch entry the value
+ is from, and `index` is the value's index in the list of values associated
+ with that feature and example.
- Raises:
- ValueError: If sparse and dense keys intersect, or input lengths do not
- match up for sparse_* (similarly for dense_*).
- TypeError: If an input is malformed.
+ Examples:
- Example input, format, and output: Just Sparse Inputs
- ================================================
+ For example, if one expects a `tf.float32` sparse feature `ft` and three
+ serialized `Example`s are provided:
- Given two brain.Example input protos:
+ ```
+ serialized = [
+ features:
+ { feature: [ key: { "ft" value: float_list: { value: [1.0, 2.0] } } ] },
+ features:
+ { feature: [] },
+ features:
+ { feature: [ key: { "ft" value: float_list: { value: [3.0] } } ] }
+ ]
+ ```
- serialized: // serialized versions of the protos below
- [features: {
+ then the output will look like:
+
+ ```
+ {"ft": SparseTensor(indices=[[0, 0], [0, 1], [2, 0]],
+ values=[1.0, 2.0, 3.0],
+ shape=(3, 2)) }
+ ```
+
+ Given two `Example` input protos in `serialized`:
+
+ ```
+ [
+ features: {
feature: { key: "kw" value: { bytes_list: { value: [ "knit", "big" ] } } }
feature: { key: "gps" value: { float_list: { value: [] } } }
- },
- features: {
+ },
+ features: {
feature: { key: "kw" value: { bytes_list: { value: [ "emmy" ] } } }
feature: { key: "dank" value: { int64_list: { value: [ 42 ] } } }
feature: { key: "gps" value: { } }
- }]
- names: ["input0", "input1"],
- sparse_keys: ["kw", "dank", "gps"]
- sparse_types: [DT_STRING, DT_INT64, DT_FLOAT]
+ }
+ ]
+ ```
- Then the expected output is a dictionary:
+ And arguments
+
+ ```
+ names: ["input0", "input1"],
+ sparse_keys: ["kw", "dank", "gps"]
+ sparse_types: [DT_STRING, DT_INT64, DT_FLOAT]
+ ```
+
+ Then the output is a dictionary:
+
+ ```python
{
"kw": SparseTensor(
indices=[[0, 0], [0, 1], [1, 0]],
@@ -132,63 +126,71 @@
values=[],
shape=[2, 0]),
}
+ ```
+ For dense results in two serialized `Example`s:
- Example input, format, and output: Dense Inputs (without defaults)
- ==================================================================
-
- Given two brain.Example input protos:
-
- serialized: // serialized versions of the protos below
- [features: {
+ ```
+ [
+ features: {
feature: { key: "age" value: { int64_list: { value: [ 0 ] } } }
feature: { key: "gender" value: { bytes_list: { value: [ "f" ] } } }
},
features: {
feature: { key: "age" value: { int64_list: { value: [] } } }
feature: { key: "gender" value: { bytes_list: { value: [ "f" ] } } }
- }]
+ }
+ ]
+ ```
+
+ We can use arguments:
+
+ ```
names: ["input0", "input1"],
- dense_keys: np.array(["age", "gender"])
- dense_types: [tf.int64, tf.string]
+ dense_keys: np.array(["age", "gender"]),
+ dense_types: [tf.int64, tf.string],
dense_defaults: {
- "age": -1 # defaults to -1 if missing
+ "age": -1 # "age" defaults to -1 if missing
# "gender" has no specified default so it's required
}
- dense_shapes: [(1,), (1,)] # age, gender, label, weight
+ dense_shapes: [(1,), (1,)], # age, gender, label, weight
+ ```
- Then the expected output is a dictionary:
+ And the expected output is:
+
+ ```python
{
"age": [[0], [-1]],
"gender": [["f"], ["f"]],
}
+ ```
+ Args:
+ serialized: A list of strings, a batch of binary serialized `Example`
+ protos.
+ names: A list of strings, the names of the serialized protos.
+ sparse_keys: A list of string keys in the examples' features.
+ The results for these keys will be returned as `SparseTensor` objects.
+ sparse_types: A list of `DTypes` of the same length as `sparse_keys`.
+ Only `tf.float32` (`FloatList`), `tf.int64` (`Int64List`),
+ and `tf.string` (`BytesList`) are supported.
+ dense_keys: A list of string keys in the examples' features.
+ The results for these keys will be returned as `Tensor`s
+ dense_types: A list of DTypes of the same length as `dense_keys`.
+ Only `tf.float32` (`FloatList`), `tf.int64` (`Int64List`),
+ and `tf.string` (`BytesList`) are supported.
+ dense_defaults: A dict mapping string keys to `Tensor`s.
+ The keys of the dict must match the dense_keys of the feature.
+ dense_shapes: A list of tuples with the same length as `dense_keys`.
+ The shape of the data for each dense feature referenced by `dense_keys`.
+ name: A name for this operation (optional).
- Example input, format, and output: Dense Inputs (with defaults)
- ===============================================================
+ Returns:
+ A `dict` mapping keys to `Tensor`s and `SparseTensor`s.
- Given two brain.Example input protos:
-
- serialized: // serialized versions of the protos below
- [features: {
- feature: { key: "weight" value: { float_list: { value: [ 1.0 ] } } }
- },
- features: {
- feature: { key: "label" value: { float_list: { value: [ -1.0, 0.0 ] } } }
- }]
- names: ["input0", "input1"],
- dense_keys: np.array(["label", "weight"])
- dense_defaults: {
- "label": [1.0, 2.0], # float (default: vector)
- "weight": 5.0 # float (default: scalar, 5.0)
- }
- dense_shapes: [(2,), (1,)] # age, gender, label, weight
-
- Then the expected output is a dictionary:
- {
- "label": [[1.0, 2.0], [-1.0, 0.0]],
- "weight": [[1.0], [5.0]],
- }
+ Raises:
+ ValueError: If sparse and dense key sets intersect, or input lengths do not
+ match up.
"""
names = [] if names is None else names
dense_defaults = {} if dense_defaults is None else dense_defaults
@@ -262,7 +264,20 @@
dense_defaults=None,
dense_shapes=None,
name="ParseSingleExample"):
- """Identical to parse_example but for scalar serialized and names.
+ """Parses a single `Example` proto.
+
+ Similar to `parse_example`, except:
+
+ For dense tensors, the returned `Tensor` is identical to the output of
+ `parse_example`, except there is no batch dimension, the output shape is the
+ same as the shape given in `dense_shape`.
+
+ For `SparseTensor`s, the first (batch) column of the indices matrix is removed
+ (the indices matrix is a column vector), the values vector is unchanged, and
+ the first (batch_size) entry of the shape vector is removed (it is now a
+ single element vector).
+
+ See also `parse_example`.
Args:
serialized: A scalar string, a single serialized Example.
@@ -275,21 +290,11 @@
dense_types: See parse_example documentation for more details.
dense_defaults: See parse_example documentation for more details.
dense_shapes: See parse_example documentation for more details.
- name: Optional op name.
+ name: A name for this operation (optional).
Returns:
A dictionary mapping keys to Tensors and SparseTensors.
- For dense tensors, the Tensor is identical to the output of parse_example,
- except it is one less dimension (the first, batch, dimension is removed).
-
- For SparseTensors:
- The first (batch) column of the indices matrix is removed
- (it is now a column vector).
- The values vector is unchanged.
- The first (batch_size) entry of the shape vector is removed
- (it is now a single element vector).
-
Raises:
ValueError: if "scalar" or "names" have known shapes, and are not scalars.
"""
diff --git a/tensorflow/python/ops/sparse_ops.py b/tensorflow/python/ops/sparse_ops.py
index c0dca61..e0209bd 100644
--- a/tensorflow/python/ops/sparse_ops.py
+++ b/tensorflow/python/ops/sparse_ops.py
@@ -1,4 +1,5 @@
-"""## Sparse Tensor Representation.
+# pylint: disable=g-short-docstring-punctuation
+"""## Sparse Tensor Representation
Tensorflow supports a `SparseTensor` representation for data that is sparse
in multiple dimensions. Contrast this representation with `IndexedSlices`,
@@ -8,13 +9,13 @@
@@SparseTensor
@@SparseTensorValue
-## Sparse to Dense Conversion.
+## Sparse to Dense Conversion
@@sparse_to_dense
@@sparse_tensor_to_dense
@@sparse_to_indicator
-## Manipulation.
+## Manipulation
@@sparse_concat
@@sparse_reorder
diff --git a/tensorflow/python/ops/state_ops.py b/tensorflow/python/ops/state_ops.py
index 1c8f38b..2e77bfa 100644
--- a/tensorflow/python/ops/state_ops.py
+++ b/tensorflow/python/ops/state_ops.py
@@ -14,7 +14,7 @@
@@initialize_variables
@@assert_variables_initialized
-## Saving and Restoring Variables.
+## Saving and Restoring Variables
@@Saver
diff --git a/tensorflow/python/ops/variables.py b/tensorflow/python/ops/variables.py
index dafd3b8..ac202bb 100644
--- a/tensorflow/python/ops/variables.py
+++ b/tensorflow/python/ops/variables.py
@@ -207,7 +207,7 @@
This convenience method requires a session where the graph containing this
variable has been launched. If no session is passed, the default session is
- used. See the [Session class](../client.md#Session) for more information on
+ used. See the [Session class](client.md#Session) for more information on
launching a graph and on sessions.
```python
@@ -543,7 +543,7 @@
"""
if var_list is None:
var_list = all_variables()
- # Backwards compatibility for old-style variables. TODO(mdevin): remove.
+ # Backwards compatibility for old-style variables. TODO(touts): remove.
if not var_list:
var_list = []
for op in ops.get_default_graph().get_operations():
diff --git a/tensorflow/python/training/checkpoint_state.proto b/tensorflow/python/training/checkpoint_state.proto
index 1f52134..3abcd71 100644
--- a/tensorflow/python/training/checkpoint_state.proto
+++ b/tensorflow/python/training/checkpoint_state.proto
@@ -5,7 +5,7 @@
// Protocol buffer representing the checkpoint state.
//
-// TODO(mdevin): Add other attributes as needed.
+// TODO(touts): Add other attributes as needed.
message CheckpointState {
// Path to the most-recent model checkpoint.
string model_checkpoint_path = 1;
diff --git a/tensorflow/python/training/input.py b/tensorflow/python/training/input.py
index 413fc04..6054d2b 100644
--- a/tensorflow/python/training/input.py
+++ b/tensorflow/python/training/input.py
@@ -329,38 +329,42 @@
shapes=None, name=None):
"""Run a list of tensors to fill a queue to create batches of examples.
- This version enqueues a different list of tensors in different threads.
- Implemented using a queue -- a QueueRunner for the queue
- is added to the current Graph's QUEUE_RUNNER collection.
+ Enqueues a different list of tensors in different threads.
+ Implemented using a queue -- a `QueueRunner` for the queue
+ is added to the current `Graph`'s `QUEUE_RUNNER` collection.
+
+ `len(tensor_list_list)` threads will be started, with thread `i` enqueuing
+ the tensors from tensor_list[i]. `tensor_list[i1][j]` must match
+ `tensor_list[i2][j]` in type and shape, except in the first dimension if
+ `enqueue_many` is true.
+
+ If `enqueue_many` is false, each `tensor_list_list[i]` is assumed to
+ represent a single example. Otherwise, `tensor_list_list[i]` is assumed to
+ represent a batch of examples, where the first dimension is indexed by
+ example, and all members of `tensor_list_list[i]` should have the same size
+ in the first dimension.
+
+ If `enqueue_many` is false, then an input tensor `x` will be output as a
+ tensor with shape `[batch_size] + x.shape`. If `enqueue_many` is true, the
+ slices of any input tensor `x` are treated as examples, and the output tensors
+ will have shape `[batch_size] + x.shape[1:]`.
+
+ The `capacity` argument controls the how long the prefetching
+ is allowed to grow the queues.
Args:
tensor_list_list: A list of tuples of tensors to enqueue.
- len(tensor_list_list) threads will be started, with the i-th
- thread enqueuing the tensors from tensor_list[i].
- tensor_list[i1][j] must match tensor_list[i2][j] in type and
- shape (except in the first dimension if enqueue_many is true).
- batch_size: The new batch size pulled from the queue.
- capacity: Maximum number of elements in the queue, controls the
- how far ahead the prefetching allowed is allowed to get and
- memory usage.
- enqueue_many: If False, each tensor_list_list[i] is assumed to
- represent a single example. If True, tensor_list_list[i] is
- assumed to represent a batch of examples, where the first
- dimension is indexed by example, and all members of
- tensor_list_list[i] should have the same size in the first
- dimension.
- shapes: Optional. The shapes for each example. Defaults to the
- inferred shapes for tensor_list_list[i] (which must match, after
- leaving off the first dimension if enqueue_many is True).
+ batch_size: An integer. The new batch size pulled from the queue.
+ capacity: An integer. The maximum number of elements in the queue.
+ enqueue_many: Whether each tensor in `tensor_list_list` is a single
+ example.
+ shapes: (Optional) The shapes for each example. Defaults to the
+ inferred shapes for `tensor_list_list[i]`.
name: A name for the operations (optional).
Returns:
A list of tensors with the same number and types as
- tensor_list_list[i]. If enqueue_many is false, then an input
- tensor with shape `[x, y, z]` will be output as a tensor with
- shape `[batch_size, x, y, z]`. If enqueue_many is True, and an
- input tensor has shape `[*, x, y, z]`, the the output will have
- shape `[batch_size, x, y, z]`.
+ `tensor_list_list[i]`.
"""
with ops.op_scope(_flatten(tensor_list_list), name, "batch_join") as name:
tensor_list_list = _validate_join(tensor_list_list)
@@ -462,15 +466,15 @@
min_after_dequeue: Minimum number elements in the queue after a
dequeue, used to ensure a level of mixing of elements.
seed: Seed for the random shuffling within the queue.
- enqueue_many: If False, each tensor_list_list[i] is assumed to
- represent a single example. If True, tensor_list_list[i] is
+ enqueue_many: If `False`, each tensor_list_list[i] is assumed to
+ represent a single example. If `True`, tensor_list_list[i] is
assumed to represent a batch of examples, where the first
dimension is indexed by example, and all members of
tensor_list_list[i] should have the same size in the first
dimension.
shapes: Optional. The shapes for each example. Defaults to the
- inferred shapes for tensor_list_list[i] (which must match, after
- leaving off the first dimension if enqueue_many is True).
+ inferred shapes for `tensor_list_list[i]` (which must match, after
+ leaving off the first dimension if enqueue_many is `True`).
name: A name for the operations (optional).
Returns:
diff --git a/tensorflow/python/training/moving_averages.py b/tensorflow/python/training/moving_averages.py
index becc71d..49fadb8 100644
--- a/tensorflow/python/training/moving_averages.py
+++ b/tensorflow/python/training/moving_averages.py
@@ -9,7 +9,7 @@
from tensorflow.python.ops import variables
-# TODO(mdevin): switch to variables.Variable.
+# TODO(touts): switch to variables.Variable.
def assign_moving_average(variable, value, decay, name=None):
"""Compute the moving average of a variable.
@@ -182,7 +182,7 @@
ValueError: If the moving average of one of the variables is already
being computed.
"""
- # TODO(mdevin): op_scope
+ # TODO(touts): op_scope
if var_list is None:
var_list = variables.trainable_variables()
for var in var_list:
diff --git a/tensorflow/python/training/saver.py b/tensorflow/python/training/saver.py
index 505bbad..8d78615 100644
--- a/tensorflow/python/training/saver.py
+++ b/tensorflow/python/training/saver.py
@@ -159,7 +159,7 @@
restore_control_inputs = assign_ops[-1:] if restore_sequentially else []
# Load and optionally reshape on the CPU, as string tensors are not
# available on the GPU.
- # TODO(mdevin): Re-enable restore on GPU when we can support annotating
+ # TODO(touts): Re-enable restore on GPU when we can support annotating
# string tensors as "HostMemory" inputs.
with ops.device(graph_util.set_cpu0(v.device) if v.device else None):
with ops.control_dependencies(restore_control_inputs):
@@ -214,7 +214,7 @@
def _GroupByDevices(self, vars_to_save):
"""Group Variable tensor slices per device.
- TODO(mdevin): Make sure that all the devices found are on different
+ TODO(touts): Make sure that all the devices found are on different
job/replica/task/cpu|gpu. It would be bad if 2 were on the same device.
It can happen if the devices as unspecified.
diff --git a/tensorflow/python/training/training.py b/tensorflow/python/training/training.py
index a400e9f..84c8156 100644
--- a/tensorflow/python/training/training.py
+++ b/tensorflow/python/training/training.py
@@ -1,7 +1,7 @@
# pylint: disable=wildcard-import,unused-import,g-bad-import-order,line-too-long
"""This library provides a set of classes and functions that helps train models.
-## Optimizers.
+## Optimizers
The Optimizer base class provides methods to compute gradients for a loss and
apply gradients to variables. A collection of subclasses implement classic
@@ -19,7 +19,7 @@
@@FtrlOptimizer
@@RMSPropOptimizer
-## Gradient Computation.
+## Gradient Computation
TensorFlow provides functions to compute the derivatives for a given
TensorFlow computation graph, adding operations to the graph. The
@@ -46,10 +46,10 @@
@@clip_by_global_norm
@@global_norm
-## Decaying the learning rate.
+## Decaying the learning rate
@@exponential_decay
-## Moving Averages.
+## Moving Averages
Some training algorithms, such as GradientDescent and Momentum often benefit
from maintaining a moving average of variables during optimization. Using the
@@ -57,7 +57,7 @@
@@ExponentialMovingAverage
-## Coordinator and QueueRunner.
+## Coordinator and QueueRunner
See [Threading and Queues](../../how_tos/threading_and_queues/index.md)
for how to use threads and queues. For documentation on the Queue API,
@@ -68,17 +68,21 @@
@@add_queue_runner
@@start_queue_runners
-## Summary Operations.
+## Summary Operations
The following ops output
[`Summary`](https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/core/framework/summary.proto)
protocol buffers as serialized string tensors.
-You can fetch the output of a summary op in a session, and pass it to a
-[SummaryWriter](train.md#SummaryWriter) to append it to an event file. You can
-then use TensorBoard to visualize the contents of the event files. See
-[TensorBoard and Summaries](../../how_tos/summaries_and_tensorboard/index.md)
-for more details.
+You can fetch the output of a summary op in a session, and pass it to
+a [SummaryWriter](train.md#SummaryWriter) to append it to an event
+file. Event files contain
+[`Event`](https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/core/util/event.proto)
+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](../../how_tos/summaries_and_tensorboard/index.md) for more
+details.
@@scalar_summary
@@image_summary
@@ -88,7 +92,7 @@
@@merge_summary
@@merge_all_summaries
-## Adding Summaries to Event Files.
+## Adding Summaries to Event Files
See [Summaries and
TensorBoard](../../how_tos/summaries_and_tensorboard/index.md) for an
@@ -97,10 +101,11 @@
@@SummaryWriter
@@summary_iterator
-## Training utilities.
+## Training utilities
@@global_step
@@write_graph
+
"""
# Optimizers.
@@ -134,5 +139,5 @@
from tensorflow.core.example.example_pb2 import *
from tensorflow.core.example.feature_pb2 import *
-# Utility op. Open Source. TODO(mdevin): move to nn?
+# Utility op. Open Source. TODO(touts): move to nn?
from tensorflow.python.training.learning_rate_decay import exponential_decay
diff --git a/third_party/eigen3/unsupported/Eigen/CXX11/src/NeuralNetworks/Patch3d.h b/third_party/eigen3/unsupported/Eigen/CXX11/src/NeuralNetworks/Patch3d.h
index df60fe1..89190eb 100644
--- a/third_party/eigen3/unsupported/Eigen/CXX11/src/NeuralNetworks/Patch3d.h
+++ b/third_party/eigen3/unsupported/Eigen/CXX11/src/NeuralNetworks/Patch3d.h
@@ -194,7 +194,7 @@
return Extract3DPatches(input, patchPlanes, patchRows, patchCols,
stridePlanes, strideRows, strideCols,
0, 0, 0, 0, 0, 0, padding_value);
- case PADDING_SAME:
+ case PADDING_SAME: {
// The side of the tensor before striding should be just the expected
// output times the stride.
const TensorIndex size_z = ceil(inputPlanes / static_cast<float>(stridePlanes)) * stridePlanes;
@@ -214,6 +214,13 @@
dy - dy / 2, dy / 2,
dx - dx / 2, dx / 2,
padding_value);
+ }
+ default:
+ eigen_assert(false && "unexpected padding");
+ // unreachable code to avoid missing return warning.
+ return Extract3DPatches(input, patchPlanes, patchRows, patchCols,
+ stridePlanes, strideRows, strideCols,
+ 0, 0, 0, 0, 0, 0, padding_value);
}
}
