From 5d59924371ed8ee15aa0431be54e2077a0c08e84 Mon Sep 17 00:00:00 2001
From: Ding Xue-wen <xuewending1995@gmail.com>
Date: Fri, 23 Mar 2018 15:30:31 +0800
Subject: [PATCH 1/7] update

---
 about/index.md                             |  1 -
 about/leftnav_files                        |  1 -
 about/roadmap.md                           | 37 ----------
 about/uses.md                              |  8 ++
 api_guides/python/contrib.distributions.md |  1 -
 api_guides/python/regression_examples.md   |  2 +-
 community/index.md                         |  1 +
 community/leftnav_files                    |  1 +
 community/roadmap.md                       | 85 ++++++++++++++++++++++
 community/welcome.md                       |  2 +-
 mobile/android_build.md                    |  4 +-
 mobile/leftnav_files                       |  1 +
 mobile/mobile_intro.md                     |  2 +-
 mobile/optimizing.md                       |  4 +-
 mobile/tflite/demo_android.md              |  3 +
 mobile/tflite/demo_ios.md                  | 68 +++++++++++++++++
 16 files changed, 174 insertions(+), 47 deletions(-)
 delete mode 100644 about/roadmap.md
 create mode 100644 community/roadmap.md
 create mode 100644 mobile/tflite/demo_ios.md

diff --git a/about/index.md b/about/index.md
index 5326b1e..dc1e9af 100644
--- a/about/index.md
+++ b/about/index.md
@@ -3,7 +3,6 @@
 This section provides a few documents about TensorFlow itself,
 including the following:
 
-  * @{$roadmap$Roadmap}, which summarizes upcoming additions to TensorFlow.
   * @{$uses$TensorFlow in Use}, which provides a link to our model zoo and
     lists some popular ways that TensorFlow is being used.
   * @{$bib$TensorFlow White Papers}, which provides abstracts of white papers
diff --git a/about/leftnav_files b/about/leftnav_files
index 28f039e..63763b9 100644
--- a/about/leftnav_files
+++ b/about/leftnav_files
@@ -1,5 +1,4 @@
 index.md
-roadmap.md
 uses.md
 bib.md
 attribution.md
diff --git a/about/roadmap.md b/about/roadmap.md
deleted file mode 100644
index 3ee825e..0000000
--- a/about/roadmap.md
+++ /dev/null
@@ -1,37 +0,0 @@
-# Roadmap
-**Last updated: January 23, 2017**
-
-TensorFlow is a fast moving project. In order for the community to better
-understand what the near future will bring, this document shares what we are
-working on internally. Many of these features were requested by the community,
-and we welcome
-[contributions](https://github.com/tensorflow/tensorflow/labels/stat%3Acontributions%20welcome).
-
-The features on this list are targeted for the next few months. At this point,
-we do not have timelines for these features.
-
-### Improve non-Python language support
-
-* Support for adding gradient computation for graphs constructed in other
-  languages (C++, Java, Go etc.)
-
-### Making TensorFlow easier to use
-* High-level APIs
-* Well-maintained models showing best practices
-
-### Performance
-* Speed and memory benchmarks
-* Distributed full model benchmarks
-* Performance and memory usage improvements
-
-### Core Features
-* Automatic op placement ([#2126](https://github.com/tensorflow/tensorflow/issues/2126))
-* Support for graph-level functions
-
-### Platforms
-* OpenCL support ([#22](https://github.com/tensorflow/tensorflow/issues/22))
-
-### Community
-* More educational resources
-* Better integration of TensorFlow into the opensource big data ecosystem (e.g.
-[#2655](https://github.com/tensorflow/tensorflow/issues/2655))
diff --git a/about/uses.md b/about/uses.md
index 8818177..d646880 100644
--- a/about/uses.md
+++ b/about/uses.md
@@ -22,6 +22,14 @@ This section describes some of the current uses of the TensorFlow system.
 > TensorFlow, or even better, send us a pull request to add an entry to this
 > file.
 
+* **Deep Speech**
+<ul>
+   <li>**Organization**: Mozilla</li>
+   <li> **Domain**: Speech Recognition</li>
+   <li> **Description**:  A TensorFlow implementation motivated by Baidu's Deep Speech architecture.</li>
+   <li> **More info**: [GitHub Repo](https://github.com/mozilla/deepspeech)</li>
+</ul>
+
 * **RankBrain**
 <ul>
    <li>**Organization**: Google</li>
diff --git a/api_guides/python/contrib.distributions.md b/api_guides/python/contrib.distributions.md
index 7a3d509..533d7da 100644
--- a/api_guides/python/contrib.distributions.md
+++ b/api_guides/python/contrib.distributions.md
@@ -17,7 +17,6 @@ initialized with parameters that define the distributions.
 
 *   @{tf.contrib.distributions.Binomial}
 *   @{tf.contrib.distributions.Bernoulli}
-*   @{tf.contrib.distributions.BernoulliWithSigmoidProbs}
 *   @{tf.contrib.distributions.Beta}
 *   @{tf.contrib.distributions.Categorical}
 *   @{tf.contrib.distributions.Chi2}
diff --git a/api_guides/python/regression_examples.md b/api_guides/python/regression_examples.md
index dae50a8..7de2be0 100644
--- a/api_guides/python/regression_examples.md
+++ b/api_guides/python/regression_examples.md
@@ -38,7 +38,7 @@ The preceding examples rely on the following data set utility:
   <tr> <th>Utility</th> <th>Description</th></tr>
 
   <tr>
-    <td><a href="http://github.com/examples/get_started/regression/imports85.py">imports85.py</a></td>
+    <td><a href="https://www.tensorflow.org/code/tensorflow/examples/get_started/regression/imports85.py">imports85.py</a></td>
     <td>This program provides utility functions that load the
         <tt>imports85</tt> data set into formats that other TensorFlow
         programs (for example, <tt>linear_regression.py</tt> and
diff --git a/community/index.md b/community/index.md
index 8e67022..b706d9b 100644
--- a/community/index.md
+++ b/community/index.md
@@ -5,6 +5,7 @@ This section contains the following documents:
   * @{$welcome$Welcome to the TensorFlow Community}, which explains how
     you can get involved, where to report issues, and where to join
     like-minded TensorFlow enthusiasts online.
+  * @{$roadmap$Roadmap}, which summarizes upcoming additions to TensorFlow.
   * @{$documentation$Writing TensorFlow Documentation}, which explains
     TensorFlow's documentation conventions.  If you are modifying
     TensorFlow source code or documentation, please read this guide.
diff --git a/community/leftnav_files b/community/leftnav_files
index c1595d3..fab3502 100644
--- a/community/leftnav_files
+++ b/community/leftnav_files
@@ -1,5 +1,6 @@
 index.md
 welcome.md
+roadmap.md
 documentation.md
 style_guide.md
 benchmarks.md
diff --git a/community/roadmap.md b/community/roadmap.md
new file mode 100644
index 0000000..a3170a1
--- /dev/null
+++ b/community/roadmap.md
@@ -0,0 +1,85 @@
+# Roadmap
+**Last updated: Feb 15, 2018**
+
+TensorFlow is a rapidly moving, community supported project. This document is intended 
+to provide guidance about priorities and focus areas of the core set of TensorFlow 
+developers and about functionality that can be expected in the upcoming releases of 
+TensorFlow. Many of these areas are driven by  community use cases, and we welcome 
+further 
+[contributions](https://github.com/tensorflow/tensorflow/blob/master/CONTRIBUTING.md) 
+to TensorFlow.
+
+The features below do not have concrete release dates. However, the majority can be 
+expected in the next one to two releases. 
+
+### APIs
+#### High Level APIs:
+* Easy multi-GPU utilization with Estimators
+* Easy-to-use high-level pre-made estimators for Gradient Boosted Trees, Time Series, and other models
+
+#### Eager Execution:
+* Efficient utilization of multiple GPUs
+* Distributed training (multi-machine)
+* Performance improvements
+* Simpler export to a GraphDef/SavedModel 
+
+#### Keras API:
+* Better integration with tf.data (ability to call `model.fit` with data tensors)
+* Full support for Eager Execution (both Eager support for the regular Keras API, and ability 
+to create Keras models Eager- style via Model subclassing)
+* Better distribution/multi-GPU support and TPU support (including a smoother model-to-estimator workflow)
+
+#### Official Models:
+* A set of 
+[reference models](https://github.com/tensorflow/models/tree/master/official) 
+across image recognition, speech, object detection, and 
+  translation that demonstrate best practices and serve as a starting point for 
+  high-performance model development.
+
+#### Contrib:
+* Deprecation notices added to parts of tf.contrib where preferred implementations exist outside of tf.contrib.
+* As much as possible, large projects inside tf.contrib moved to separate repositories.
+* The tf.contrib module will eventually be discontinued in its current form, experimental development will in future happen in other repositories.
+
+
+#### Probabilistic Reasoning and Statistical Analysis:
+* Rich set of tools for probabilistic and statistical analysis in tf.distributions 
+  and tf.probability. These include new samplers, layers, optimizers, losses, and structured models
+* Statistical tools for hypothesis testing, convergence diagnostics, and sample statistics
+* Edward 2.0: High-level API for probabilistic programming
+
+### Platforms
+#### TensorFlow Lite:
+* Increased coverage of supported ops in TensorFlow Lite
+* Easier conversion of a trained TensorFlow graph for use on TensorFlow Lite
+* Support for GPU acceleration in TensorFlow Lite (iOS and Android)
+* Support for hardware accelerators via Android NeuralNets API 
+* Improved CPU performance by quantization and other network optimizations (eg. pruning, distillation)
+* Increased support for devices beyond Android and iOS (eg. RPi, Cortex-M)
+
+### Performance
+#### Distributed TensorFlow:
+* Multi-GPU support optimized for a variety of GPU topologies
+* Improved mechanisms for distributing computations on several machines
+
+#### Optimizations:
+* Mixed precision training support with initial example model and guide
+* Native TensorRT support
+* Int8 support for SkyLake via MKL
+* Dynamic loading of SIMD-optimized kernels
+
+### Documentation and Usability:
+* Updated documentation, tutorials and Getting Started guides
+* Process to enable external contributions to tutorials, documentation, and blogs showcasing best practice use-cases of TensorFlow and high-impact applications
+
+### Community and Partner Engagement
+#### Special Interest Groups: 
+* Mobilizing the community to work together in focused domains
+* [tf-distribute](https://groups.google.com/a/tensorflow.org/forum/#!forum/tf-distribute): build and packaging of TensorFlow
+* More to be identified and launched
+
+#### Community:
+* Incorporate public feedback on significant design decisions via a Request-for-Comment (RFC) process
+* Formalize process for external contributions to land in TensorFlow and associated projects 
+* Grow global TensorFlow communities and user groups
+* Collaborate with partners to co-develop and publish research papers
diff --git a/community/welcome.md b/community/welcome.md
index d2d3f9e..9f6fe91 100644
--- a/community/welcome.md
+++ b/community/welcome.md
@@ -65,5 +65,5 @@ please read the following list carefully:
     on GitHub.  For example, use the issue tracker to request a
     new operation in TensorFlow.
   * To report vulnerabilities, please follow our
-    [vulnerability disclosure guidelines](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md).
+    [vulnerability disclosure guidelines](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/SECURITY.md).
 
diff --git a/mobile/android_build.md b/mobile/android_build.md
index b5a1d5d..08a5fbe 100644
--- a/mobile/android_build.md
+++ b/mobile/android_build.md
@@ -90,8 +90,8 @@ using [ADB](https://developer.android.com/studio/command-line/adb.html). This
 requires some knowledge of build systems and Android developer tools, but we'll
 guide you through the basics here.
 
-- First, follow our instructions for @{$install/install_sources$installing from
-  sources}. This will also guide you through installing Bazel and cloning the
+- First, follow our instructions for @{$install/install_sources$installing from sources}.
+  This will also guide you through installing Bazel and cloning the
   TensorFlow code.
 
 - Download the Android [SDK](https://developer.android.com/studio/index.html)
diff --git a/mobile/leftnav_files b/mobile/leftnav_files
index ac50f52..4cf134c 100644
--- a/mobile/leftnav_files
+++ b/mobile/leftnav_files
@@ -2,6 +2,7 @@ index.md
 ### TensorFlow Lite
 tflite/index.md
 tflite/demo_android.md
+tflite/demo_ios.md
 >>>
 ### TensorFlow Mobile
 mobile_intro.md
diff --git a/mobile/mobile_intro.md b/mobile/mobile_intro.md
index 17dbf1c..69b63ae 100644
--- a/mobile/mobile_intro.md
+++ b/mobile/mobile_intro.md
@@ -235,7 +235,7 @@ TensorFlow [on Github](https://github.com/tensorflow/models) that you can look
 through. Lean towards the simplest model you can find, and try to get started as
 soon as you have even a small amount of labelled data, since you’ll get the best
 results when you’re able to iterate quickly. The shorter the time it takes to
-try training a model and running it in s real application, the better overall
+try training a model and running it in its real application, the better overall
 results you’ll see. It’s common for an algorithm to get great training accuracy
 numbers but then fail to be useful within a real application because there’s a
 mismatch between the dataset and real usage. Prototype end-to-end usage as soon
diff --git a/mobile/optimizing.md b/mobile/optimizing.md
index 44cacff..ca9cb04 100644
--- a/mobile/optimizing.md
+++ b/mobile/optimizing.md
@@ -290,8 +290,8 @@ run it on a 64-bit ARM device:
 
 You can interpret the results in exactly the same way as the desktop version
 above. If you have any trouble figuring out what the right input and output
-names and types are, take a look at the @{$mobile/prepare_models$Preparing
-models} page for details about detecting these for your model, and look at the
+names and types are, take a look at the @{$mobile/prepare_models$Preparing models}
+page for details about detecting these for your model, and look at the
 `summarize_graph` tool which may give you
 helpful information.
 
diff --git a/mobile/tflite/demo_android.md b/mobile/tflite/demo_android.md
index 79b5678..c94b559 100644
--- a/mobile/tflite/demo_android.md
+++ b/mobile/tflite/demo_android.md
@@ -8,6 +8,9 @@ You'll need an Android device running Android 5.0 or higher to run the demo.
 To get you started working with TensorFlow Lite on Android, we'll walk you
 through building and deploying our TensorFlow demo app in Android Studio.
 
+Note: For a more detailed guide see the
+[TFLite Codelab](https://codelabs.developers.google.com/codelabs/tensorflow-for-poets-2-tflite/index.html#0)
+
 It's also possible to build the demo app with Bazel, but we only recommend
 this for advanced users who are very familiar with the Bazel build
 environment. For more information on that, see our page [on Github](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/lite#building-tensorflow-lite-and-the-demo-app-from-source).
diff --git a/mobile/tflite/demo_ios.md b/mobile/tflite/demo_ios.md
new file mode 100644
index 0000000..3ee9b1c
--- /dev/null
+++ b/mobile/tflite/demo_ios.md
@@ -0,0 +1,68 @@
+# TensorFlow Lite Demo for iOS
+
+The TensorFlow Lite demo is a camera app that continuously classifies whatever
+it sees from your device's back camera, using a quantized MobileNet model. These
+instructions walk you through building and running the demo on an iOS device.
+
+## Prerequisites
+
+* You must have [Xcode](https://developer.apple.com/xcode/) installed and have a
+  valid Apple Developer ID, and have an iOS device set up and linked to your
+  developer account with all of the appropriate certificates. For these
+  instructions, we assume that you have already been able to build and deploy an
+  app to an iOS device with your current developer environment.
+
+* The demo app requires a camera and must be executed on a real iOS device. You
+  can build it and run with the iPhone Simulator but it won't have any camera
+  information to classify.
+
+* You don't need to build the entire TensorFlow library to run the demo, but you
+  will need to clone the TensorFlow repository if you haven't already:
+
+        git clone https://github.com/tensorflow/tensorflow
+
+* You'll also need the Xcode command-line tools:
+
+        xcode-select --install
+
+    If this is a new install, you will need to run the Xcode application once to
+    agree to the license before continuing.
+
+## Building the iOS Demo App
+
+1. Install CocoaPods if you don't have it:
+
+        sudo gem install cocoapods
+
+2. Download the model files used by the demo app (this is done from inside the
+   cloned directory):
+
+        sh tensorflow/contrib/lite/examples/ios/download_models.sh
+
+3. Install the pod to generate the workspace file:
+
+        cd tensorflow/contrib/lite/examples/ios/camera
+        pod install
+
+    If you have installed this pod before and that command doesn't work, try
+
+        pod update
+
+    At the end of this step you should have a file called 
+    `tflite_camera_example.xcworkspace`.
+
+4. Open the project in Xcode by typing this on the command line:
+
+        open tflite_camera_example.xcworkspace
+
+    This launches Xcode if it isn't open already and opens the
+    `tflite_camera_example` project.
+
+5. Build and run the app in Xcode.
+
+    Note that as mentioned earlier, you must already have a device set up and
+    linked to your Apple Developer account in order to deploy the app on a
+    device.
+
+You'll have to grant permissions for the app to use the device's camera. Point
+the camera at various objects and enjoy seeing how the model classifies things!

From 0bce98656a10916ccf82837bba93d0c41459cae5 Mon Sep 17 00:00:00 2001
From: Ding Xue-wen <xuewending1995@gmail.com>
Date: Fri, 23 Mar 2018 21:06:00 +0800
Subject: [PATCH 2/7] update to v1.7

---
 README.md                                     |  37 +-
 deploy/index.md                               |   2 +
 deploy/leftnav_files                          |   1 +
 deploy/s3.md                                  |  40 ++
 extend/add_filesys.md                         |   2 +
 get_started/checkpoints.md                    |   4 +-
 get_started/custom_estimators.md              |  14 +-
 get_started/datasets_quickstart.md            |  89 ++--
 get_started/feature_columns.md                |  12 +-
 get_started/get_started_for_beginners.md      |  19 +-
 install/index.md                              |   2 +-
 install/install_c.md                          |   4 +-
 install/install_go.md                         |   4 +-
 install/install_java.md                       |  24 +-
 install/install_linux.md                      |  54 +-
 install/install_mac.md                        |  29 +-
 install/install_sources.md                    |  14 +-
 install/install_windows.md                    |   3 +-
 performance/datasets_performance.md           |   8 +-
 performance/leftnav_files                     |   4 +-
 performance/quantization.md                   | 461 +++++++++---------
 performance/xla/operation_semantics.md        | 280 +++++++++--
 programmers_guide/datasets.md                 |  40 +-
 programmers_guide/debugger.md                 |  21 +-
 programmers_guide/faq.md                      |   3 +-
 programmers_guide/graphs.md                   |  13 +-
 programmers_guide/index.md                    |   6 +-
 programmers_guide/low_level_intro.md          |  23 +-
 programmers_guide/saved_model.md              | 185 +++----
 .../summaries_and_tensorboard.md              |  18 +-
 programmers_guide/variables.md                |   5 +-
 programmers_guide/version_compat.md           |   3 +-
 tutorials/image_retraining.md                 |  31 +-
 tutorials/index.md                            |   2 +-
 tutorials/layers.md                           |   5 +-
 tutorials/wide.md                             |  14 +-
 36 files changed, 925 insertions(+), 551 deletions(-)
 create mode 100644 deploy/s3.md

diff --git a/README.md b/README.md
index c754c3f..ef5bdc6 100644
--- a/README.md
+++ b/README.md
@@ -4,9 +4,10 @@
 
 -----------------
 
-| **`Linux CPU`** | **`Linux GPU`** | **`Mac OS CPU`** | **`Windows CPU`** | **`Android`** |
-|-----------------|---------------------|------------------|-------------------|---------------|
-| [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-cpu)](https://ci.tensorflow.org/job/tensorflow-master-cpu) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-linux-gpu)](https://ci.tensorflow.org/job/tensorflow-master-linux-gpu) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-mac)](https://ci.tensorflow.org/job/tensorflow-master-mac) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-win-cmake-py)](https://ci.tensorflow.org/job/tensorflow-master-win-cmake-py) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-android)](https://ci.tensorflow.org/job/tensorflow-master-android) [ ![Download](https://api.bintray.com/packages/google/tensorflow/tensorflow/images/download.svg) ](https://bintray.com/google/tensorflow/tensorflow/_latestVersion) |
+
+| **`Documentation`** | **`Linux CPU`** | **`Linux GPU`** | **`Mac OS CPU`** | **`Windows CPU`** | **`Android`** |
+|-----------------|---------------------|------------------|-------------------|---------------|---------------|
+| [![Documentation](https://img.shields.io/badge/api-reference-blue.svg)](https://www.tensorflow.org/api_docs/) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-cpu)](https://ci.tensorflow.org/job/tensorflow-master-cpu) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-linux-gpu)](https://ci.tensorflow.org/job/tensorflow-master-linux-gpu) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-mac)](https://ci.tensorflow.org/job/tensorflow-master-mac) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-win-cmake-py)](https://ci.tensorflow.org/job/tensorflow-master-win-cmake-py) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-android)](https://ci.tensorflow.org/job/tensorflow-master-android) [ ![Download](https://api.bintray.com/packages/google/tensorflow/tensorflow/images/download.svg) ](https://bintray.com/google/tensorflow/tensorflow/_latestVersion)
 
 **TensorFlow** is an open source software library for numerical computation using
 data flow graphs.  The graph nodes represent mathematical operations, while
@@ -21,20 +22,6 @@ organization for the purposes of conducting machine learning and deep neural
 networks research.  The system is general enough to be applicable in a wide
 variety of other domains, as well.
 
-**If you want to contribute to TensorFlow, be sure to review the [contribution
-guidelines](CONTRIBUTING.md). This project adheres to TensorFlow's
-[code of conduct](CODE_OF_CONDUCT.md). By participating, you are expected to
-uphold this code.**
-
-**We use [GitHub issues](https://github.com/tensorflow/tensorflow/issues) for
-tracking requests and bugs. So please see 
-[TensorFlow Discuss](https://groups.google.com/a/tensorflow.org/forum/#!forum/discuss) for general questions
-and discussion, and please direct specific questions to [Stack Overflow](https://stackoverflow.com/questions/tagged/tensorflow).**
-
-The TensorFlow project strives to abide by generally accepted best practices in open-source software development:
-
-[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/1486/badge)](https://bestpractices.coreinfrastructure.org/projects/1486)
-
 ## Installation
 *See [Installing TensorFlow](https://www.tensorflow.org/get_started/os_setup.html) for instructions on how to install our release binaries or how to build from source.*
 
@@ -75,6 +62,22 @@ $ python
 >>> sess.close()
 ```
 
+## Contribution guidelines
+
+**If you want to contribute to TensorFlow, be sure to review the [contribution
+guidelines](CONTRIBUTING.md). This project adheres to TensorFlow's
+[code of conduct](CODE_OF_CONDUCT.md). By participating, you are expected to
+uphold this code.**
+
+**We use [GitHub issues](https://github.com/tensorflow/tensorflow/issues) for
+tracking requests and bugs. So please see
+[TensorFlow Discuss](https://groups.google.com/a/tensorflow.org/forum/#!forum/discuss) for general questions
+and discussion, and please direct specific questions to [Stack Overflow](https://stackoverflow.com/questions/tagged/tensorflow).**
+
+The TensorFlow project strives to abide by generally accepted best practices in open-source software development:
+
+[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/1486/badge)](https://bestpractices.coreinfrastructure.org/projects/1486)
+
 ## For more information
 
 * [TensorFlow Website](https://www.tensorflow.org)
diff --git a/deploy/index.md b/deploy/index.md
index 5831960..07b1bc9 100644
--- a/deploy/index.md
+++ b/deploy/index.md
@@ -7,6 +7,8 @@ the following documents:
     a cluster of TensorFlow servers.
   * @{$hadoop$How to run TensorFlow on Hadoop}, which has a highly
     self-explanatory title.
+  * @{$s3$How to run TensorFlow with the S3 filesystem}, which explains how
+    to run TensorFlow with the S3 file system.
   * The entire document set for [TensorFlow serving](/serving), an open-source,
     flexible, high-performance serving system for machine-learned models
     designed for production environments. TensorFlow Serving provides
diff --git a/deploy/leftnav_files b/deploy/leftnav_files
index f8f8d57..c682e7a 100644
--- a/deploy/leftnav_files
+++ b/deploy/leftnav_files
@@ -1,3 +1,4 @@
 index.md
 distributed.md
 hadoop.md
+s3.md
diff --git a/deploy/s3.md b/deploy/s3.md
new file mode 100644
index 0000000..38f8428
--- /dev/null
+++ b/deploy/s3.md
@@ -0,0 +1,40 @@
+# How to run TensorFlow on S3
+
+This document describes how to run TensorFlow on S3 file system.
+
+## S3
+
+We assume that you are familiar with @{$reading_data$reading data}.
+
+To use S3 with TensorFlow, change the file paths you use to read and write
+data to an S3 path. For example:
+
+```python
+filenames = ["s3://bucketname/path/to/file1.tfrecord",
+             "s3://bucketname/path/to/file2.tfrecord"]
+dataset = tf.data.TFRecordDataset(filenames)
+```
+
+When reading or writing data on S3 with your TensorFlow program, the behavior
+could be controlled by various environmental variables:
+
+*   **AWS_REGION**: By default, regional endpoint is used for S3, with region
+    controlled by `AWS_REGION`. If `AWS_REGION` is not specified, then
+    `us-east-1` is used.
+*   **S3_ENDPOINT**: The endpoint could be overridden explicitly with
+    `S3_ENDPOINT` specified.
+*   **S3_USE_HTTPS**: HTTPS is used to access S3 by default, unless
+    `S3_USE_HTTPS=0`.
+*   **S3_VERIFY_SSL**: If HTTPS is used, SSL verification could be disabled
+    with `S3_VERIFY_SSL=0`.
+
+To read or write objects in a bucket that is no publicly accessible,
+AWS credentials must be provided through one of the following methods:
+
+*   Set credentials in the AWS credentials profile file on the local system,
+    located at: `~/.aws/credentials` on Linux, macOS, or Unix, or
+    `C:\Users\USERNAME\.aws\credentials` on Windows.
+*   Set the `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` environment
+    variables.
+*   If TensorFlow is deployed on an EC2 instance, specify an IAM role and then
+    give the EC2 instance access to that role.
diff --git a/extend/add_filesys.md b/extend/add_filesys.md
index f0591b7..06f11de 100644
--- a/extend/add_filesys.md
+++ b/extend/add_filesys.md
@@ -81,6 +81,8 @@ filesystem implementations call their existing libraries. Examples include:
     plugin](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/platform/hadoop/hadoop_file_system.h)
 *   [GCS
     plugin](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/platform/cloud/gcs_file_system.h)
+*   [S3
+    plugin](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/platform/s3/s3_file_system.h)
 
 #### The File interfaces
 
diff --git a/get_started/checkpoints.md b/get_started/checkpoints.md
index dfa2110..4aa07c7 100644
--- a/get_started/checkpoints.md
+++ b/get_started/checkpoints.md
@@ -154,7 +154,7 @@ classifier = tf.estimator.DNNClassifier(
 
 The first time you call an Estimator's `train` method, TensorFlow saves a
 checkpoint to the `model_dir`. Each subsequent call to the Estimator's
-`train`, `eval`, or `predict` method causes the following:
+`train`, `evaluate`, or `predict` method causes the following:
 
 1.  The Estimator builds the model's
     [graph](https://developers.google.com/machine-learning/glossary/#graph)
@@ -222,7 +222,7 @@ does not match the shape stored in checkpoint: [20]
 
 To run experiments in which you train and compare slightly different
 versions of a model, save a copy of the code that created each
-`model-dir`, possibly by creating a separate git branch for each version.
+`model_dir`, possibly by creating a separate git branch for each version.
 This separation will keep your checkpoints recoverable.
 
 ## Summary
diff --git a/get_started/custom_estimators.md b/get_started/custom_estimators.md
index 79c4ee7..941c3e1 100644
--- a/get_started/custom_estimators.md
+++ b/get_started/custom_estimators.md
@@ -161,12 +161,12 @@ classifier = tf.estimator.Estimator(
 
 To implement a typical model function, you must do the following:
 
-* (Define the model)[#define_the_model].
+* [Define the model](#define_the_model).
 * Specify additional calculations for each of
   the [three different modes](#modes):
-  * [Predict](#predict)
-  * [Evaluate](#evaluate)
-  * [Train](#train)
+    * [Predict](#predict)
+    * [Evaluate](#evaluate)
+    * [Train](#train)
 
 ## Define the model
 
@@ -213,7 +213,7 @@ is connected to every node in the preceding layer.  Here's the relevant code:
 ```
 
 * The `units` parameter defines the number of output neurons in a given layer.
-* The `activation` parameter defines the [activation function](https://developers.google.com/machine-learning/glossary/#a) —
+* The `activation` parameter defines the [activation function](https://developers.google.com/machine-learning/glossary/#activation_function) —
   [Relu](https://developers.google.com/machine-learning/glossary/#ReLU) in this
   case.
 
@@ -546,8 +546,8 @@ In brief, here's what the three graphs tell you:
 
 * accuracy: The accuracy is recorded by the following two lines:
 
-  * `eval_metric_ops={'my_accuracy': accuracy})`, during evaluation.
-  * `tf.summary.scalar('accuracy', accuracy[1])`, during training.
+    * `eval_metric_ops={'my_accuracy': accuracy})`, during evaluation.
+    * `tf.summary.scalar('accuracy', accuracy[1])`, during training.
 
 These tensorboard graphs are one of the main reasons it's important to pass a
 `global_step` to your optimizer's `minimize` method. The model can't record
diff --git a/get_started/datasets_quickstart.md b/get_started/datasets_quickstart.md
index a8a2ab6..c972e5e 100644
--- a/get_started/datasets_quickstart.md
+++ b/get_started/datasets_quickstart.md
@@ -28,8 +28,8 @@ def train_input_fn(features, labels, batch_size):
     # Shuffle, repeat, and batch the examples.
     dataset = dataset.shuffle(1000).repeat().batch(batch_size)
 
-    # Build the Iterator, and return the read end of the pipeline.
-    return dataset.make_one_shot_iterator().get_next()
+    # Return the dataset.
+    return dataset
 ```
 
 Let's look at this more closely.
@@ -40,7 +40,7 @@ This function expects three arguments. Arguments expecting an "array" can
 accept nearly anything that can be converted to an array with `numpy.array`.
 One exception is
 [`tuple`](https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences)
-which has special meaning for `Datasets`.
+which, as we will see, has special meaning for `Datasets`.
 
 * `features`: A `{'feature_name':array}` dictionary (or
   [`DataFrame`](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.html))
@@ -73,11 +73,12 @@ Let's walk through the `train_input_fn()`.
 
 ### Slices
 
-In the simplest cases, @{tf.data.Dataset.from_tensor_slices} function takes an
-array and returns a @{tf.data.Dataset} representing slices of the array. For
-example, an array containing the @{$tutorials/layers$mnist training data}
-has a shape of `(60000, 28, 28)`. Passing this to `from_tensor_slices` returns
-a `Dataset` object containing 60000 slices, each one a 28x28 image.
+The function starts by using the @{tf.data.Dataset.from_tensor_slices} function
+to create a @{tf.data.Dataset} representing slices of the array. The array is
+sliced across the first dimension. For example, an array containing the
+@{$tutorials/layers$mnist training data} has a shape of `(60000, 28, 28)`.
+Passing this to `from_tensor_slices` returns a `Dataset` object containing
+60000 slices, each one a 28x28 image.
 
 The code that returns this `Dataset` is as follows:
 
@@ -89,18 +90,24 @@ mnist_ds = tf.data.Dataset.from_tensor_slices(mnist_x)
 print(mnist_ds)
 ```
 
-This will print the following line, showing the @{$programmers_guide/tensors#shapes$shapes} and @{$programmers_guide/tensors#data_types$types} of the items in
-the dataset. Note that the dataset does not know how many items it contains.
+This will print the following line, showing the
+@{$programmers_guide/tensors#shapes$shapes} and
+@{$programmers_guide/tensors#data_types$types} of the items in
+the dataset. Note that a `Dataset` does not know how many items it contains.
 
 ``` None
 <TensorSliceDataset shapes: (28,28), types: tf.uint8>
 ```
 
-The dataset above represents a collection of simple arrays, but datasets are
-much more powerful than this. Datasets transparently handle any nested
-combination of dictionaries or tuples. For example, ensuring that `features`
-is a standard dictionary, you can then convert the dictionary of arrays to
-a `Dataset` of dictionaries as follows:
+The `Dataset` above represents a simple collection of arrays, but datasets are
+much more powerful than this. A `Dataset` can transparently handle any nested
+combination of dictionaries or tuples (or
+[`namedtuple`](https://docs.python.org/2/library/collections.html#collections.namedtuple)
+).
+
+For example after converting the iris `features`
+to a standard python dictionary, you can then convert the dictionary of arrays
+to a `Dataset` of dictionaries as follows:
 
 ``` python
 dataset = tf.data.Dataset.from_tensor_slices(dict(features))
@@ -124,9 +131,9 @@ and `types` of the `Dataset` take on the same structure. This dataset contains
 dictionaries of @{$programmers_guide/tensors#rank$scalars}, all of type
 `tf.float64`.
 
-The first line of `train_input_fn` uses the same functionality, but adds
-another level of structure. It creates a dataset containing
-`(features, labels)` pairs.
+The first line of the iris `train_input_fn` uses the same functionality, but
+adds another level of structure. It creates a dataset containing
+`(features_dict, label)` pairs.
 
 The following code shows that the label is a scalar with type `int64`:
 
@@ -164,14 +171,14 @@ dataset = dataset.shuffle(1000).repeat().batch(batch_size)
 ```
 
 The @{tf.data.Dataset.shuffle$`shuffle`} method uses a fixed-size buffer to
-shuffle the items as they pass through. Setting a `buffer_size` greater than
-the number of examples in the `Dataset` ensures that the data is completely
-shuffled. The Iris data set only contains 150 examples.
+shuffle the items as they pass through. In this case the `buffer_size` is
+greater than the number of examples in the `Dataset`, ensuring that the data is
+completely shuffled (The Iris data set only contains 150 examples).
 
-The @{tf.data.Dataset.repeat$`repeat`} method has the `Dataset` restart when
+The @{tf.data.Dataset.repeat$`repeat`} method restarts the `Dataset` when
 it reaches the end. To limit the number of epochs, set the `count` argument.
 
-The @{tf.data.Dataset.repeat$`batch`} method collects a number of examples and
+The @{tf.data.Dataset.batch$`batch`} method collects a number of examples and
 stacks them, to create batches. This adds a dimension to their shape. The new
 dimension is added as the first dimension. The following code uses
 the `batch` method on the MNIST `Dataset`, from earlier. This results in a
@@ -213,35 +220,16 @@ print(dataset)
 
 ### Return
 
-<!-- TODO(markdaoust) This line can be simplified to "return dataset" -->
+At this point the `Dataset` contains `(features_dict, labels)` pairs.
+This is the format expected by the `train` and `evaluate` methods, so the
+`input_fn` returns the dataset.
 
-The `train`, `evaluate`, and `predict` methods of every Estimator require
-input functions to return a `(features, label)` pair containing
-@{$programmers_guide/tensors$tensorflow tensors}. The `train_input_fn` uses
-the following line to convert the Dataset into the expected format:
+The `labels` can/should be omitted when using the `predict` method.
 
-```python
-# Build the Iterator, and return the read end of the pipeline.
-features_result, labels_result = dataset.make_one_shot_iterator().get_next()
-```
+<!--
+  TODO(markdaoust): link to `input_fn` doc when it exists
+-->
 
-The result is a structure of @{$programmers_guide/tensors$TensorFlow tensors},
-matching the layout of the items in the `Dataset`.
-For an introduction to what these objects are and how to work with them,
-see @{$programmers_guide/low_level_intro}.
-
-``` python
-print((features_result, labels_result))
-```
-
-```None
-({
-    'SepalLength': <tf.Tensor 'IteratorGetNext:2' shape=(?,) dtype=float64>,
-    'PetalWidth': <tf.Tensor 'IteratorGetNext:1' shape=(?,) dtype=float64>,
-    'PetalLength': <tf.Tensor 'IteratorGetNext:0' shape=(?,) dtype=float64>,
-    'SepalWidth': <tf.Tensor 'IteratorGetNext:3' shape=(?,) dtype=float64>},
-Tensor("IteratorGetNext_1:4", shape=(?,), dtype=int64))
-```
 
 ## Reading a CSV File
 
@@ -277,9 +265,6 @@ ds = tf.data.TextLineDataset(train_path).skip(1)
 
 ### Build a csv line parser
 
-Ultimately we will need to parse each of the lines in the dataset, to
-produce the necessary `(features, label)` pairs.
-
 We will start by building a function to parse a single line.
 
 The following `iris_data.parse_line` function accomplishes this task using the
diff --git a/get_started/feature_columns.md b/get_started/feature_columns.md
index ad3e1fe..d8e4bec 100644
--- a/get_started/feature_columns.md
+++ b/get_started/feature_columns.md
@@ -146,10 +146,10 @@ single input number into a four-element vector. Therefore, the model now can
 learn _four individual weights_ rather than just one; four weights creates a
 richer model than one weight. More importantly, bucketizing enables the model
 to clearly distinguish between different year categories since only one of the
-elements is set (1) and the other three elements are cleared (0). When we just
-use a single number (a year) as input, the model can only learn a linear
-relationship. So, bucketing provides the model with additional flexibility that
-the model can use to learn.
+elements is set (1) and the other three elements are cleared (0). For example,
+when we just use a single number (a year) as input, a linear model can only
+learn a linear relationship. So, bucketing provides the model with additional
+flexibility that the model can use to learn.
 
 The following code demonstrates how to create a bucketized feature:
 
@@ -242,7 +242,7 @@ on an explicit vocabulary list. For example:
 # the elements in the vocabulary list.
 vocabulary_feature_column =
     tf.feature_column.categorical_column_with_vocabulary_list(
-        key="a feature returned by input_fn()",
+        key=feature_name_from_input_fn,
         vocabulary_list=["kitchenware", "electronics", "sports"])
 ```
 
@@ -259,7 +259,7 @@ you place the vocabulary words in a separate file. For example:
 # the elements in the vocabulary file
 vocabulary_feature_column =
     tf.feature_column.categorical_column_with_vocabulary_file(
-        key="a feature returned by input_fn()",
+        key=feature_name_from_input_fn,
         vocabulary_file="product_class.txt",
         vocabulary_size=3)
 ```
diff --git a/get_started/get_started_for_beginners.md b/get_started/get_started_for_beginners.md
index 446bae4..b88483b 100644
--- a/get_started/get_started_for_beginners.md
+++ b/get_started/get_started_for_beginners.md
@@ -91,11 +91,10 @@ a number.  Here's the representation scheme:
 
 A **model** is the relationship between features
 and the label.  For the Iris problem, the model defines the relationship
-between the sepal and petal measurements and the Iris species.
-Some simple models can be described with a few lines of algebra;
-more complex machine learning models
-contain such a large number of interlacing mathematical functions and
-parameters that they become hard to summarize mathematically.
+between the sepal and petal measurements and the predicted Iris species. Some
+simple models can be described with a few lines of algebra, but complex machine
+learning models have a large number of parameters that are difficult to
+summarize.
 
 Could you determine the relationship between the four features and the
 Iris species *without* using machine learning?  That is, could you use
@@ -333,7 +332,7 @@ interpret data is such a rich topic that we devote an entire
 From a code perspective, you build a list of `feature_column` objects by calling
 functions from the @{tf.feature_column} module. Each object describes an input
 to the model. To tell the model to interpret data as a floating-point value,
-call @{tf.feature_column.numeric_column).  In `premade_estimator.py`, all
+call @{tf.feature_column.numeric_column}.  In `premade_estimator.py`, all
 four features should be interpreted as literal floating-point values, so
 the code to create a feature column looks as follows:
 
@@ -359,7 +358,7 @@ my_feature_columns = [
 
 ### Select the type of model
 
-We need the select the kind of model that will be trained.
+We need to select the kind of model that will be trained.
 Lots of model types exist; picking the ideal type takes experience.
 We've selected a neural network to solve the Iris problem.  [**Neural
 networks**](https://developers.google.com/machine-learning/glossary/#neural_network)
@@ -659,7 +658,9 @@ calls as follows:
 
 ```python
 predictions = classifier.predict(
-    input_fn=lambda:eval_input_fn(predict_x, batch_size=args.batch_size))
+    input_fn=lambda:eval_input_fn(predict_x,
+                                  labels=None,
+                                  batch_size=args.batch_size))
 ```
 
 As with the `evaluate` method, our `predict` method also gathers examples
@@ -704,7 +705,7 @@ for pred_dict, expec in zip(predictions, expected):
 
     class_id = pred_dict['class_ids'][0]
     probability = pred_dict['probabilities'][class_id]
-    print(template.format(SPECIES[class_id], 100 * probability, expec))
+    print(template.format(iris_data.SPECIES[class_id], 100 * probability, expec))
 ```
 
 Running the program yields the following output:
diff --git a/install/index.md b/install/index.md
index 3c84886..4f85383 100644
--- a/install/index.md
+++ b/install/index.md
@@ -3,7 +3,7 @@
 We've built and tested TensorFlow on the following 64-bit laptop/desktop
 operating systems:
 
-  * MacOS X 10.11 (El Capitan) or later.
+  * macOS 10.12.6 (Sierra) or later.
   * Ubuntu 16.04 or later
   * Windows 7 or later.
 
diff --git a/install/install_c.md b/install/install_c.md
index 1a151ec..9059b3f 100644
--- a/install/install_c.md
+++ b/install/install_c.md
@@ -15,7 +15,7 @@ instructions might also work on other variants, we have only tested
 following requirements:
 
   * Linux, 64-bit, x86
-  * macOS X, Version 10.11 (El Capitan) or higher
+  * macOS X, Version 10.12.6 (Sierra) or higher
 
 
 ## Installation
@@ -38,7 +38,7 @@ enable TensorFlow for C:
          OS="linux" # Change to "darwin" for macOS
          TARGET_DIRECTORY="/usr/local"
          curl -L \
-           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-$%7BTF_TYPE%7D-$%7BOS%7D-x86_64-1.6.0.tar.gz" |
+           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-$%7BTF_TYPE%7D-$%7BOS%7D-x86_64-1.7.0-rc1.tar.gz" |
            sudo tar -C $TARGET_DIRECTORY -xz
 
      The `tar` command extracts the TensorFlow C library into the `lib`
diff --git a/install/install_go.md b/install/install_go.md
index bc874c0..2e47a6d 100644
--- a/install/install_go.md
+++ b/install/install_go.md
@@ -17,7 +17,7 @@ instructions might also work on other variants, we have only tested
 following requirements:
 
   * Linux, 64-bit, x86
-  * macOS X, 10.11 (El Capitan) or higher
+  * macOS X, 10.12.6 (Sierra) or higher
 
 
 ## Installation
@@ -38,7 +38,7 @@ steps to install this library and enable TensorFlow for Go:
          TF_TYPE="cpu" # Change to "gpu" for GPU support
          TARGET_DIRECTORY='/usr/local'
          curl -L \
-           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-$%7BTF_TYPE%7D-$(go%20env%20GOOS)-x86_64-1.6.0.tar.gz" |
+           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-$%7BTF_TYPE%7D-$(go%20env%20GOOS)-x86_64-1.7.0-rc1.tar.gz" |
          sudo tar -C $TARGET_DIRECTORY -xz
 
      The `tar` command extracts the TensorFlow C library into the `lib`
diff --git a/install/install_java.md b/install/install_java.md
index 313de20..eff066d 100644
--- a/install/install_java.md
+++ b/install/install_java.md
@@ -18,7 +18,7 @@ instructions might also work on other variants, we have only tested
 following requirements:
 
   * Ubuntu 16.04 or higher; 64-bit, x86
-  * macOS X 10.11 (El Capitan) or higher
+  * macOS 10.12.6 (Sierra) or higher
   * Windows 7 or higher; 64-bit, x86
 
 The installation instructions for Android are in a separate
@@ -36,7 +36,7 @@ following to the project's `pom.xml` to use the TensorFlow Java APIs:
 <dependency>
   <groupId>org.tensorflow</groupId>
   <artifactId>tensorflow</artifactId>
-  <version>1.6.0</version>
+  <version>1.7.0-rc1</version>
 </dependency>
 ```
 
@@ -65,7 +65,7 @@ As an example, these steps will create a Maven project that uses TensorFlow:
                <dependency>
                  <groupId>org.tensorflow</groupId>
                  <artifactId>tensorflow</artifactId>
-                 <version>1.6.0</version>
+                 <version>1.7.0-rc1</version>
                </dependency>
              </dependencies>
          </project>
@@ -123,12 +123,12 @@ instead:
 <dependency>
   <groupId>org.tensorflow</groupId>
   <artifactId>libtensorflow</artifactId>
-  <version>1.6.0</version>
+  <version>1.7.0-rc1</version>
 </dependency>
 <dependency>
   <groupId>org.tensorflow</groupId>
   <artifactId>libtensorflow_jni_gpu</artifactId>
-  <version>1.6.0</version>
+  <version>1.7.0-rc1</version>
 </dependency>
 ```
 
@@ -147,7 +147,7 @@ refer to the simpler instructions above instead.
 Take the following steps to install TensorFlow for Java on Linux or macOS:
 
   1. Download
-     [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.6.0.jar),
+     [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.7.0-rc1.jar),
      which is the TensorFlow Java Archive (JAR).
 
   2. Decide whether you will run TensorFlow for Java on CPU(s) only or with
@@ -166,7 +166,7 @@ Take the following steps to install TensorFlow for Java on Linux or macOS:
          OS=$(uname -s | tr '[:upper:]' '[:lower:]')
          mkdir -p ./jni
          curl -L \
-           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-$%7BTF_TYPE%7D-$%7BOS%7D-x86_64-1.6.0.tar.gz" |
+           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-$%7BTF_TYPE%7D-$%7BOS%7D-x86_64-1.7.0-rc1.tar.gz" |
            tar -xz -C ./jni
 
 ### Install on Windows
@@ -174,10 +174,10 @@ Take the following steps to install TensorFlow for Java on Linux or macOS:
 Take the following steps to install TensorFlow for Java on Windows:
 
   1. Download
-     [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.6.0.jar),
+     [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.7.0-rc1.jar),
      which is the TensorFlow Java Archive (JAR).
   2. Download the following Java Native Interface (JNI) file appropriate for
-     [TensorFlow for Java on Windows](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-cpu-windows-x86_64-1.6.0.zip).
+     [TensorFlow for Java on Windows](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-cpu-windows-x86_64-1.7.0-rc1.zip).
   3. Extract this .zip file.
 
 
@@ -225,7 +225,7 @@ must be part of your `classpath`. For example, you can include the
 downloaded `.jar` in your `classpath` by using the `-cp` compilation flag
 as follows:
 
-<pre><b>javac -cp libtensorflow-1.6.0.jar HelloTF.java</b></pre>
+<pre><b>javac -cp libtensorflow-1.7.0-rc1.jar HelloTF.java</b></pre>
 
 
 ### Running
@@ -239,11 +239,11 @@ two files are available to the JVM:
 For example, the following command line executes the `HelloTF` program on Linux
 and macOS X:
 
-<pre><b>java -cp libtensorflow-1.6.0.jar:. -Djava.library.path=./jni HelloTF</b></pre>
+<pre><b>java -cp libtensorflow-1.7.0-rc1.jar:. -Djava.library.path=./jni HelloTF</b></pre>
 
 And the following command line executes the `HelloTF` program on Windows:
 
-<pre><b>java -cp libtensorflow-1.6.0.jar;. -Djava.library.path=jni HelloTF</b></pre>
+<pre><b>java -cp libtensorflow-1.7.0-rc1.jar;. -Djava.library.path=jni HelloTF</b></pre>
 
 If the program prints <tt>Hello from <i>version</i></tt>, you've successfully
 installed TensorFlow for Java and are ready to use the API.  If the program
diff --git a/install/install_linux.md b/install/install_linux.md
index be74a0d..378946b 100644
--- a/install/install_linux.md
+++ b/install/install_linux.md
@@ -189,7 +189,7 @@ Take the following steps to install TensorFlow with Virtualenv:
      Virtualenv environment:
 
      <pre>(tensorflow)$ <b>pip3 install --upgrade \
-     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.6.0-cp34-cp34m-linux_x86_64.whl</b></pre>
+     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.7.0rc1-cp34-cp34m-linux_x86_64.whl</b></pre>
 
 If you encounter installation problems, see
 [Common Installation Problems](#common_installation_problems).
@@ -294,7 +294,7 @@ take the following steps:
 
      <pre>
      $ <b>sudo pip3 install --upgrade \
-     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.6.0-cp34-cp34m-linux_x86_64.whl</b>
+     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.7.0rc1-cp34-cp34m-linux_x86_64.whl</b>
      </pre>
 
      If this step fails, see
@@ -357,24 +357,23 @@ where:
     to 6006.
   * <tt><i>TensorFlowCPUImage</i></tt> is required. It identifies the Docker
     container. Specify one of the following values:
-    * <tt>gcr.io/tensorflow/tensorflow</tt>, which is the TensorFlow CPU binary image.
-    * <tt>gcr.io/tensorflow/tensorflow:latest-devel</tt>, which is the latest
+    * <tt>tensorflow/tensorflow</tt>, which is the TensorFlow CPU binary image.
+    * <tt>tensorflow/tensorflow:latest-devel</tt>, which is the latest
       TensorFlow CPU Binary image plus source code.
-    * <tt>gcr.io/tensorflow/tensorflow:<i>version</i></tt>, which is the
+    * <tt>tensorflow/tensorflow:<i>version</i></tt>, which is the
       specified version (for example, 1.1.0rc1) of TensorFlow CPU binary image.
-    * <tt>gcr.io/tensorflow/tensorflow:<i>version</i>-devel</tt>, which is
+    * <tt>tensorflow/tensorflow:<i>version</i>-devel</tt>, which is
       the specified version (for example, 1.1.0rc1) of the TensorFlow GPU
       binary image plus source code.
 
-    <tt>gcr.io</tt> is the Google Container Registry. Note that some
-    TensorFlow images are also available at
+    TensorFlow images are available at
     [dockerhub](https://hub.docker.com/r/tensorflow/tensorflow/).
 
 For example, the following command launches the latest TensorFlow CPU binary image
 in a Docker container from which you can run TensorFlow programs in a shell:
 
 <pre>
-$ <b>docker run -it gcr.io/tensorflow/tensorflow bash</b>
+$ <b>docker run -it tensorflow/tensorflow bash</b>
 </pre>
 
 The following command also launches the latest TensorFlow CPU binary image in a
@@ -382,7 +381,7 @@ Docker container. However, in this Docker container, you can run TensorFlow
 programs in a Jupyter notebook:
 
 <pre>
-$ <b>docker run -it -p 8888:8888 gcr.io/tensorflow/tensorflow</b>
+$ <b>docker run -it -p 8888:8888 tensorflow/tensorflow</b>
 </pre>
 
 Docker will download the TensorFlow binary image the first time you launch it.
@@ -406,14 +405,14 @@ where:
     <tt><i>hostPort</i></tt> and <code><em>containerPort</em></code> to `8888`.
   * <i>TensorFlowGPUImage</i> specifies the Docker container. You must
     specify one of the following values:
-    * <tt>gcr.io/tensorflow/tensorflow:latest-gpu</tt>, which is the latest
+    * <tt>tensorflow/tensorflow:latest-gpu</tt>, which is the latest
       TensorFlow GPU binary image.
-    * <tt>gcr.io/tensorflow/tensorflow:latest-devel-gpu</tt>, which is
+    * <tt>tensorflow/tensorflow:latest-devel-gpu</tt>, which is
       the latest TensorFlow GPU Binary image plus source code.
-    * <tt>gcr.io/tensorflow/tensorflow:<i>version</i>-gpu</tt>, which is the
+    * <tt>tensorflow/tensorflow:<i>version</i>-gpu</tt>, which is the
       specified version (for example, 0.12.1) of the TensorFlow GPU
       binary image.
-    * <tt>gcr.io/tensorflow/tensorflow:<i>version</i>-devel-gpu</tt>, which is
+    * <tt>tensorflow/tensorflow:<i>version</i>-devel-gpu</tt>, which is
       the specified version (for example, 0.12.1) of the TensorFlow GPU
       binary image plus source code.
 
@@ -422,7 +421,7 @@ following command launches the latest TensorFlow GPU binary image in a
 Docker container from which you can run TensorFlow programs in a shell:
 
 <pre>
-$ <b>nvidia-docker run -it gcr.io/tensorflow/tensorflow:latest-gpu bash</b>
+$ <b>nvidia-docker run -it tensorflow/tensorflow:latest-gpu bash</b>
 </pre>
 
 The following command also launches the latest TensorFlow GPU binary image
@@ -430,13 +429,13 @@ in a Docker container. In this Docker container, you can run TensorFlow
 programs in a Jupyter notebook:
 
 <pre>
-$ <b>nvidia-docker run -it -p 8888:8888 gcr.io/tensorflow/tensorflow:latest-gpu</b>
+$ <b>nvidia-docker run -it -p 8888:8888 tensorflow/tensorflow:latest-gpu</b>
 </pre>
 
 The following command installs an older TensorFlow version (0.12.1):
 
 <pre>
-$ <b>nvidia-docker run -it -p 8888:8888 gcr.io/tensorflow/tensorflow:0.12.1-gpu</b>
+$ <b>nvidia-docker run -it -p 8888:8888 tensorflow/tensorflow:0.12.1-gpu</b>
 </pre>
 
 Docker will download the TensorFlow binary image the first time you launch it.
@@ -481,8 +480,7 @@ Take the following steps to install TensorFlow in an Anaconda environment:
 
      <pre>
      (tensorflow)$ <b>pip install --ignore-installed --upgrade \
-     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.6.0-cp34-cp34m-linux_x86_64.whl</b></pre>
-
+     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.7.0rc1-cp34-cp34m-linux_x86_64.whl</b></pre>
 
 <a name="ValidateYourInstallation"></a>
 ## Validate your installation
@@ -507,7 +505,7 @@ If you installed through Docker, start a Docker container
 from which you can run bash. For example:
 
 <pre>
-$ <b>docker run -it gcr.io/tensorflow/tensorflow bash</b>
+$ <b>docker run -it tensorflow/tensorflow bash</b>
 </pre>
 
 
@@ -649,14 +647,14 @@ This section documents the relevant values for Linux installations.
 CPU only:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.6.0-cp27-none-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.7.0rc1-cp27-none-linux_x86_64.whl
 </pre>
 
 
 GPU support:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.6.0-cp27-none-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.7.0rc1-cp27-none-linux_x86_64.whl
 </pre>
 
 Note that GPU support requires the NVIDIA hardware and software described in
@@ -668,14 +666,14 @@ Note that GPU support requires the NVIDIA hardware and software described in
 CPU only:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.6.0-cp34-cp34m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.7.0rc1-cp34-cp34m-linux_x86_64.whl
 </pre>
 
 
 GPU support:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.6.0-cp34-cp34m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.7.0rc1-cp34-cp34m-linux_x86_64.whl
 </pre>
 
 Note that GPU support requires the NVIDIA hardware and software described in
@@ -687,14 +685,14 @@ Note that GPU support requires the NVIDIA hardware and software described in
 CPU only:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.6.0-cp35-cp35m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.7.0rc1-cp35-cp35m-linux_x86_64.whl
 </pre>
 
 
 GPU support:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.6.0-cp35-cp35m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.7.0rc1-cp35-cp35m-linux_x86_64.whl
 </pre>
 
 
@@ -706,14 +704,14 @@ Note that GPU support requires the NVIDIA hardware and software described in
 CPU only:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.6.0-cp36-cp36m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.7.0rc1-cp36-cp36m-linux_x86_64.whl
 </pre>
 
 
 GPU support:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.6.0-cp36-cp36m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.7.0rc1-cp36-cp36m-linux_x86_64.whl
 </pre>
 
 
diff --git a/install/install_mac.md b/install/install_mac.md
index 62f8963..fa6951a 100644
--- a/install/install_mac.md
+++ b/install/install_mac.md
@@ -5,7 +5,11 @@ instructions might also work on other macOS variants, we have only
 tested (and we only support) these instructions on machines meeting the
 following requirements:
 
-  * macOS X 10.11 (El Capitan) or higher
+  * macOS 10.12.6 (Sierra) or higher
+
+Note: There are known, accuracy-affecting numerical issues before macOS 10.12.6
+(Sierra) that are described in
+[GitHub#15933](https://github.com/tensorflow/tensorflow/issues/15933#issuecomment-366331383).
 
 Note: As of version 1.2, TensorFlow no longer provides GPU support on macOS.
 
@@ -115,7 +119,7 @@ Take the following steps to install TensorFlow with Virtualenv:
      TensorFlow in the active Virtualenv is as follows:
 
      <pre> $ <b>pip3 install --upgrade \
-     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.6.0-py3-none-any.whl</b></pre>
+     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.7.0rc1-py3-none-any.whl</b></pre>
 
 If you encounter installation problems, see
 [Common Installation Problems](#common-installation-problems).
@@ -238,7 +242,7 @@ take the following steps:
      issue the following command:
 
      <pre> $ <b>sudo pip3 install --upgrade \
-     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.6.0-py3-none-any.whl</b> </pre>
+     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.7.0rc1-py3-none-any.whl</b> </pre>
 
      If the preceding command fails, see
      [installation problems](#common-installation-problems).
@@ -288,24 +292,23 @@ where:
     to 6006.
   * <i>TensorFlowImage</i> is required. It identifies the Docker container.
     You must specify one of the following values:
-    * <code>gcr.io/tensorflow/tensorflow</code>: TensorFlow binary image.
-    * <code>gcr.io/tensorflow/tensorflow:latest-devel</code>: TensorFlow
+    * <code>tensorflow/tensorflow</code>: TensorFlow binary image.
+    * <code>tensorflow/tensorflow:latest-devel</code>: TensorFlow
       Binary image plus source code.
 
-<code>gcr.io</code> is the Google Container Registry. Note that some
-TensorFlow images are also available at
+The TensorFlow images are available at
 [dockerhub](https://hub.docker.com/r/tensorflow/tensorflow/).
 
 For example, the following command launches a TensorFlow CPU binary image
 in a Docker container from which you can run TensorFlow programs in a shell:
 
-<pre>$ <b>docker run -it gcr.io/tensorflow/tensorflow bash</b></pre>
+<pre>$ <b>docker run -it tensorflow/tensorflow bash</b></pre>
 
 The following command also launches a TensorFlow CPU binary image in a
 Docker container. However, in this Docker container, you can run
 TensorFlow programs in a Jupyter notebook:
 
-<pre>$ <b>docker run -it -p 8888:8888 gcr.io/tensorflow/tensorflow</b></pre>
+<pre>$ <b>docker run -it -p 8888:8888 tensorflow/tensorflow</b></pre>
 
 Docker will download the TensorFlow binary image the first time you launch it.
 
@@ -347,7 +350,7 @@ Take the following steps to install TensorFlow in an Anaconda environment:
      TensorFlow for Python 2.7:
 
      <pre> (<i>targetDirectory</i>)$ <b>pip install --ignore-installed --upgrade \
-     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.6.0-py2-none-any.whl</b></pre>
+     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.7.0rc1-py2-none-any.whl</b></pre>
 
 
 <a name="ValidateYourInstallation"></a>
@@ -372,7 +375,7 @@ do the following:
 If you installed through Docker, start a Docker container that runs bash.
 For example:
 
-<pre>$ <b>docker run -it gcr.io/tensorflow/tensorflow bash</b></pre>
+<pre>$ <b>docker run -it tensorflow/tensorflow bash</b></pre>
 
 
 
@@ -520,7 +523,7 @@ This section documents the relevant values for Mac OS installations.
 
 
 <pre>
-https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.6.0-py2-none-any.whl
+https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.7.0rc1-py2-none-any.whl
 </pre>
 
 
@@ -528,5 +531,5 @@ https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.6.0-py2-none-any.
 
 
 <pre>
-https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.6.0-py3-none-any.whl
+https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.7.0rc1-py3-none-any.whl
 </pre>
diff --git a/install/install_sources.md b/install/install_sources.md
index 638a64c..0454c17 100644
--- a/install/install_sources.md
+++ b/install/install_sources.md
@@ -221,7 +221,7 @@ problem, do either of the following:
   * Download Xcode 7.2 and select it as your default by issuing the following
     command:
 
-    <pre> $ <b>sudo xcode-select -s /Application/Xcode-7.2/Xcode.app</b></pre>
+    <pre> $ <b>sudo xcode-select -s /Applications/Xcode-7.2/Xcode.app</b></pre>
 
 **NOTE:** Your system must fulfill the NVIDIA software requirements described
 in one of the following documents:
@@ -359,10 +359,10 @@ Invoke `pip install` to install that pip package.
 The filename of the `.whl` file depends on your platform.
 For example, the following command will install the pip package
 
-for TensorFlow 1.6.0 on Linux:
+for TensorFlow 1.7.0rc1 on Linux:
 
 <pre>
-$ <b>sudo pip install /tmp/tensorflow_pkg/tensorflow-1.6.0-py2-none-any.whl</b>
+$ <b>sudo pip install /tmp/tensorflow_pkg/tensorflow-1.7.0rc1-py2-none-any.whl</b>
 </pre>
 
 ## Validate your installation
@@ -393,8 +393,7 @@ TensorFlow programs:
 
 <pre>Hello, TensorFlow!</pre>
 
-If you are new to TensorFlow, see @{$get_started/get_started$Getting Started with
-TensorFlow}.
+If you are new to TensorFlow, see @{$get_started/premade_estimators$Getting Started with TensorFlow}.
 
 If the system outputs an error message instead of a greeting, see [Common
 installation problems](#common_installation_problems).
@@ -460,6 +459,8 @@ Stack Overflow and specify the `tensorflow` tag.
 **Linux**
 <table>
 <tr><th>Version:</th><th>CPU/GPU:</th><th>Python Version:</th><th>Compiler:</th><th>Build Tools:</th><th>cuDNN:</th><th>CUDA:</th></tr>
+<tr><td>tensorflow-1.7.0rc1</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.10.0</td><td>N/A</td><td>N/A</td></tr>
+<tr><td>tensorflow_gpu-1.7.0rc1</td><td>GPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.9.0</td><td>7</td><td>9</td></tr>
 <tr><td>tensorflow-1.6.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.9.0</td><td>N/A</td><td>N/A</td></tr>
 <tr><td>tensorflow_gpu-1.6.0</td><td>GPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.9.0</td><td>7</td><td>9</td></tr>
 <tr><td>tensorflow-1.5.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.8.0</td><td>N/A</td><td>N/A</td></tr>
@@ -479,6 +480,7 @@ Stack Overflow and specify the `tensorflow` tag.
 **Mac**
 <table>
 <tr><th>Version:</th><th>CPU/GPU:</th><th>Python Version:</th><th>Compiler:</th><th>Build Tools:</th><th>cuDNN:</th><th>CUDA:</th></tr>
+<tr><td>tensorflow-1.7.0rc1</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>Clang from xcode</td><td>Bazel 0.10.1</td><td>N/A</td><td>N/A</td></tr>
 <tr><td>tensorflow-1.6.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>Clang from xcode</td><td>Bazel 0.8.1</td><td>N/A</td><td>N/A</td></tr>
 <tr><td>tensorflow-1.5.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>Clang from xcode</td><td>Bazel 0.8.1</td><td>N/A</td><td>N/A</td></tr>
 <tr><td>tensorflow-1.4.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>Clang from xcode</td><td>Bazel 0.5.4</td><td>N/A</td><td>N/A</td></tr>
@@ -493,6 +495,8 @@ Stack Overflow and specify the `tensorflow` tag.
 **Windows**
 <table>
 <tr><th>Version:</th><th>CPU/GPU:</th><th>Python Version:</th><th>Compiler:</th><th>Build Tools:</th><th>cuDNN:</th><th>CUDA:</th></tr>
+<tr><td>tensorflow-1.7.0rc1</td><td>CPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>N/A</td><td>N/A</td></tr>
+<tr><td>tensorflow_gpu-1.7.0rc1</td><td>GPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>7</td><td>9</td></tr>
 <tr><td>tensorflow-1.6.0</td><td>CPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>N/A</td><td>N/A</td></tr>
 <tr><td>tensorflow_gpu-1.6.0</td><td>GPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>7</td><td>9</td></tr>
 <tr><td>tensorflow-1.5.0</td><td>CPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>N/A</td><td>N/A</td></tr>
diff --git a/install/install_windows.md b/install/install_windows.md
index a837c7d..2413bc9 100644
--- a/install/install_windows.md
+++ b/install/install_windows.md
@@ -154,8 +154,7 @@ TensorFlow programs:
 
 <pre>Hello, TensorFlow!</pre>
 
-If you are new to TensorFlow, see @{$get_started/get_started$Getting Started with
-TensorFlow}.
+If you are new to TensorFlow, see @{$get_started/premade_estimators$Getting Started with TensorFlow}.
 
 If the system outputs an error message instead of a greeting, see [Common
 installation problems](#common_installation_problems).
diff --git a/performance/datasets_performance.md b/performance/datasets_performance.md
index 4f95e17..46b43b7 100644
--- a/performance/datasets_performance.md
+++ b/performance/datasets_performance.md
@@ -92,11 +92,11 @@ transform the data.
 
 Without pipelining, the CPU and the GPU/TPU sit idle much of the time:
 
-![without pipelining](https://www.tensorflow.org/images/datasets_without_pipelining.png)
+![without pipelining](/images/datasets_without_pipelining.png)
 
 With pipelining, idle time diminishes significantly:
 
-![with pipelining](https://www.tensorflow.org/images/datasets_with_pipelining.png)
+![with pipelining](/images/datasets_with_pipelining.png)
 
 The `tf.data` API provides a software pipelining mechanism through the
 @{tf.data.Dataset.prefetch} transformation, which can be used to decouple the
@@ -139,7 +139,7 @@ multiple CPU cores. To make this possible, the `map` transformation provides the
 the following diagram illustrates the effect of setting `num_parallel_calls=2`
 to the `map` transformation:
 
-![parallel map](https://www.tensorflow.org/images/datasets_parallel_map.png)
+![parallel map](/images/datasets_parallel_map.png)
 
 Choosing the best value for the `num_parallel_calls` argument depends on your
 hardware, characteristics of your training data (such as its size and shape),
@@ -213,7 +213,7 @@ number of datasets to overlap can be specified by the `cycle_length` argument.
 The following diagram illustrates the effect of supplying `cycle_length=2` to
 the `parallel_interleave` transformation:
 
-![parallel io](https://www.tensorflow.org/images/datasets_parallel_io.png)
+![parallel io](/images/datasets_parallel_io.png)
 
 To apply this change to our running example, change:
 
diff --git a/performance/leftnav_files b/performance/leftnav_files
index 316f023..d11a7e5 100644
--- a/performance/leftnav_files
+++ b/performance/leftnav_files
@@ -2,6 +2,7 @@ performance_guide.md
 datasets_performance.md
 performance_models.md
 benchmarks.md
+quantization.md
 
 ### XLA
 xla/index.md
@@ -11,6 +12,3 @@ xla/jit.md
 xla/operation_semantics.md
 xla/shapes.md
 xla/tfcompile.md
-
-### Quantization
-quantization.md
diff --git a/performance/quantization.md b/performance/quantization.md
index 544274c..411889c 100644
--- a/performance/quantization.md
+++ b/performance/quantization.md
@@ -1,226 +1,253 @@
-# How to Quantize Neural Networks with TensorFlow
-
-When modern neural networks were being developed, the biggest challenge was
-getting them to work at all! That meant that accuracy and speed during training
-were the top priorities. Using floating point arithmetic was the easiest way to
-preserve accuracy, and GPUs were well-equipped to accelerate those calculations,
-so it's natural that not much attention was paid to other numerical formats.
-
-These days, we actually have a lot of models being deployed in commercial
-applications. The computation demands of training grow with the number of
-researchers, but the cycles needed for inference expand in proportion to users.
-That means pure inference efficiency has become a burning issue for a lot of
-teams.
-
-That is where quantization comes in. It's an umbrella term that covers a lot of
-different techniques to store numbers and perform calculations on them in more
-compact formats than 32-bit floating point. I am going to focus on eight-bit
-fixed point, for reasons I'll go into more detail on later.
-
-[TOC]
-
-## Why does Quantization Work?
-
-Training neural networks is done by applying many tiny nudges to the weights,
-and these small increments typically need floating point precision to work
-(though there are research efforts to use quantized representations here too).
-
-Taking a pre-trained model and running inference is very different. One of the
-magical qualities of deep networks is that they tend to cope very well with high
-levels of noise in their inputs. If you think about recognizing an object in a
-photo you've just taken, the network has to ignore all the CCD noise, lighting
-changes, and other non-essential differences between it and the training
-examples it's seen before, and focus on the important similarities instead. This
-ability means that they seem to treat low-precision calculations as just another
-source of noise, and still produce accurate results even with numerical formats
-that hold less information.
-
-## Why Quantize?
-
-Neural network models can take up a lot of space on disk, with the original
-AlexNet being over 200 MB in float format for example. Almost all of that size
-is taken up with the weights for the neural connections, since there are often
-many millions of these in a single model. Because they're all slightly different
-floating point numbers, simple compression formats like zip don't compress them
-well. They are arranged in large layers though, and within each layer the
-weights tend to be normally distributed within a certain range, for example -3.0
-to 6.0.
-
-The simplest motivation for quantization is to shrink file sizes by storing the
-min and max for each layer, and then compressing each float value to an
-eight-bit integer representing the closest real number in a linear set of 256
-within the range. For example with the -3.0 to 6.0 range, a 0 byte would
-represent -3.0, a 255 would stand for 6.0, and 128 would represent about 1.5.
-I'll go into the exact calculations later, since there's some subtleties, but
-this means you can get the benefit of a file on disk that's shrunk by 75%, and
-then convert back to float after loading so that your existing floating-point
-code can work without any changes.
-
-Another reason to quantize is to reduce the computational resources you need to
-do the inference calculations, by running them entirely with eight-bit inputs
-and outputs. This is a lot more difficult since it requires changes everywhere
-you do calculations, but offers a lot of potential rewards. Fetching eight-bit
-values only requires 25% of the memory bandwidth of floats, so you'll make much
-better use of caches and avoid bottlenecking on RAM access. You can also
-typically use SIMD operations that do many more operations per clock cycle. In
-some case you'll have a DSP chip available that can accelerate eight-bit
-calculations too, which can offer a lot of advantages.
-
-Moving calculations over to eight bit will help you run your models faster, and
-use less power (which is especially important on mobile devices). It also opens
-the door to a lot of embedded systems that can't run floating point code
-efficiently, so it can enable a lot of applications in the IoT world.
-
-## Why Not Train in Lower Precision Directly?
-
-There have been some experiments training at lower bit depths, but the results
-seem to indicate that you need higher than eight bit to handle the back
-propagation and gradients. That makes implementing the training more
-complicated, and so starting with inference made sense. We also already have a
-lot of float models already that we use and know well, so being able to convert
-them directly is very convenient.
-
-## How Can You Quantize Your Models?
-
-TensorFlow has production-grade support for eight-bit calculations built in. It
-also has a process for converting many models trained in floating-point over to
-equivalent graphs using quantized calculations for inference. For example,
-here's how you can translate the latest GoogLeNet model into a version that uses
-eight-bit computations:
-
-```sh
-curl -L "https://storage.googleapis.com/download.tensorflow.org/models/inception_v3_2016_08_28_frozen.pb.tar.gz" |
-  tar -C tensorflow/examples/label_image/data -xz
-bazel build tensorflow/tools/graph_transforms:transform_graph
-bazel-bin/tensorflow/tools/graph_transforms/transform_graph \
-  --in_graph=tensorflow/examples/label_image/data/inception_v3_2016_08_28_frozen.pb \
-  --out_graph=/tmp/quantized_graph.pb \
-  --inputs=input \
-  --outputs=InceptionV3/Predictions/Reshape_1 \
-  --transforms='add_default_attributes strip_unused_nodes(type=float, shape="1,299,299,3")
-    remove_nodes(op=Identity, op=CheckNumerics) fold_constants(ignore_errors=true)
-    fold_batch_norms fold_old_batch_norms quantize_weights quantize_nodes
-    strip_unused_nodes sort_by_execution_order'
+# Fixed Point Quantization
+
+Quantization techniques store and calculate numbers in more compact formats.
+[TensorFlow Lite](/mobile/tflite/) adds quantization that uses an 8-bit fixed
+point representation.
+
+Since a challenge for modern neural networks is optimizing for high accuracy, the
+priority has been improving accuracy and speed during training. Using floating
+point arithmetic is an easy way to preserve accuracy and GPUs are designed to
+accelerate these calculations.
+
+However, as more machine learning models are deployed to mobile devices,
+inference efficiency has become a critical issue. Where the computational demand
+for *training* grows with the amount of models trained on different
+architectures, the computational demand for *inference* grows in proportion to
+the amount of users.
+
+## Quantization benefits
+
+
+Using 8-bit calculations help your models run faster and use less power. This is
+especially important for mobile devices and embedded applications that can't run
+floating point code efficiently, for example, Internet of Things (IoT) and
+robotics devices. There are additional opportunities to extend this support to
+more backends and research lower precision networks.
+
+### Smaller file sizes {: .hide-from-toc}
+
+Neural network models require a lot of space on disk. For example, the original
+AlexNet requires over 200 MB for the float format—almost all of that for the
+model's millions of weights. Because the weights are slightly different
+floating point numbers, simple compression formats perform poorly (like zip).
+
+Weights fall in large layers of numerical values. For each layer, weights tend to
+be normally distributed within a range. Quantization can shrink file sizes by
+storing the minimum and maximum weight for each layer, then compress each
+weight's float value to an 8-bit integer representing the closest real number in
+a linear set of 256 within the range.
+
+### Faster inference {: .hide-from-toc}
+
+Since calculations are run entirely on 8-bit inputs and outputs, quantization
+reduces the computational resources needed for inference calculations. This is
+more involved, requiring changes to all floating point calculations, but results
+in a large speed-up for inference time.
+
+### Memory efficiency {: .hide-from-toc}
+
+Since fetching 8-bit values only requires 25% of the memory bandwidth of floats,
+more efficient caches avoid bottlenecks for RAM access. In many cases, the power
+consumption for running a neural network is dominated by memory access. The
+savings from using fixed-point 8-bit weights and activations are significant. 
+
+Typically, SIMD operations are available that run more operations per clock
+cycle. In some cases, a DSP chip is available that accelerates 8-bit calculations
+resulting in a massive speedup.
+
+## Fixed point quantization techniques
+
+The goal is to use the same precision for weights and activations during both
+training and inference. But an important difference is that training consists of
+a forward pass and a backward pass, while inference only uses a forward pass.
+When we train the model with quantization in the loop, we ensure that the forward
+pass matches precision for both training and inference.
+
+To minimize the loss in accuracy for fully fixed point models (weights and
+activations), train the model with quantization in the loop. This simulates
+quantization in the forward pass of a model so weights tend towards values that
+perform better during quantized inference. The backward pass uses quantized
+weights and activations and models quantization as a straight through estimator.
+(See Bengio et al., [2013](https://arxiv.org/abs/1308.3432))
+
+Additionally, the minimum and maximum values for activations are determined
+during training. This allows a model trained with quantization in the loop to be
+converted to a fixed point inference model with little effort, eliminating the
+need for a separate calibration step.
+
+## Quantization training with TensorFlow
+
+TensorFlow can train models with quantization in the loop. Because training
+requires small gradient adjustments, floating point values are still used. To
+keep models as floating point while adding the quantization error in the training
+loop, @{$array_ops#Fake_quantization$fake quantization} nodes simulate the
+effect of quantization in the forward and backward passes.
+
+Since it's difficult to add these fake quantization operations to all the
+required locations in the model, there's a function available that rewrites the
+training graph. To create a fake quantized training graph:
+
+```
+# Build forward pass of model.
+loss = tf.losses.get_total_loss()
+
+# Call the training rewrite which rewrites the graph in-place with
+# FakeQuantization nodes and folds batchnorm for training. It is
+# often needed to fine tune a floating point model for quantization
+# with this training tool. When training from scratch, quant_delay
+# can be used to activate quantization after training to converge
+# with the float graph, effectively fine-tuning the model.
+tf.contrib.quantize.create_training_graph(quant_delay=2000000)
+
+# Call backward pass optimizer as usual.
+optimizer = tf.train.GradientDescentOptimizer(learning_rate)
+optimizer.minimize(loss)
 ```
 
-This will produce a new model that runs the same operations as the original, but
-with eight bit calculations internally, and all weights quantized as well. If
-you look at the file size, you'll see it's about a quarter of the original (23MB
-versus 91MB). You can still run this model using exactly the same inputs and
-outputs though, and you should get equivalent results. Here's an example:
+The rewritten *eval graph* is non-trivially different from the *training graph*
+since the quantization ops affect the batch normalization step. Because of this,
+we've added a separate rewrite for the *eval graph*:
 
-```sh
-bazel build tensorflow/examples/label_image:label_image
-bazel-bin/tensorflow/examples/label_image/label_image \
---graph=/tmp/quantized_graph.pb \
+```
+# Build eval model
+logits = tf.nn.softmax_cross_entropy_with_logits(...)
+
+# Call the eval rewrite which rewrites the graph in-place with
+# FakeQuantization nodes and fold batchnorm for eval.
+tf.contrib.quantize.create_eval_graph()
+
+# Save the checkpoint and eval graph proto to disk for freezing
+# and providing to TFLite.
+with open(eval_graph_file, ‘w’) as f:
+  f.write(str(g.as_graph_def()))
+saver = tf.train.Saver()
+saver.save(sess, checkpoint_name)
+```
+
+Methods to rewrite the training and eval graphs are an active area of research
+and experimentation. Although rewrites and quantized training might not work or
+improve performance for all models, we are working to generalize these
+techniques.
+
+## Generating fully quantized models
+
+The previously demonstrated after-rewrite eval graph only *simulates*
+quantization. To generate real fixed point computations from a trained
+quantization model, convert it to a fixed point kernel. Tensorflow Lite supports
+this conversion from the graph resulting from `create_eval_graph`.
+
+First, create a frozen graph that will be the input for the TensorFlow Lite
+toolchain:
+
+```
+bazel build tensorflow/python/tools:freeze_graph && \
+  bazel-bin/tensorflow/python/tools/freeze_graph \
+  --input_graph=eval_graph_def.pb \
+  --input_checkpoint=checkpoint \
+  --output_graph=frozen_eval_graph.pb --output_node_names=outputs
 ```
 
-You'll see that this runs the newly-quantized graph, and outputs a very similar
-answer to the original.
-
-You can run the same process on your own models saved out as GraphDefs, with the
-input and output names adapted to those your network requires. I recommend that
-you run them through the freeze_graph script first, to convert checkpoints into
-constants stored in the file.
-
-## How Does the Quantization Process Work?
-
-We've implemented quantization by writing equivalent eight-bit versions of
-operations that are commonly used during inference. These include convolution,
-matrix multiplication, activation functions, pooling operations and
-concatenation. The conversion script first replaces all the individual ops it
-knows about with quantized equivalents. These are small sub-graphs that have
-conversion functions before and after to move the data between float and
-eight-bit. Below is an example of what they look like. First here's the original
-Relu operation, with float inputs and outputs:
-
-![Relu Diagram](https://www.tensorflow.org/images/quantization0.png)
-
-Then, this is the equivalent converted subgraph, still with float inputs and
-outputs, but with internal conversions so the calculations are done in eight
-bit.
-
-![Converted Diagram](https://www.tensorflow.org/images/quantization1.png)
-
-The min and max operations actually look at the values in the input float
-tensor, and then feeds them into the Dequantize operation that converts the
-tensor into eight-bits. There are more details on how the quantized representation
-works later on.
-
-Once the individual operations have been converted, the next stage is to remove
-unnecessary conversions to and from float. If there are consecutive sequences of
-operations that all have float equivalents, then there will be a lot of adjacent
-Dequantize/Quantize ops. This stage spots that pattern, recognizes that they
-cancel each other out, and removes them, like this:
-
-![Stripping Diagram](https://www.tensorflow.org/images/quantization2.png)
-
-Applied on a large scale to models where all of the operations have quantized
-equivalents, this gives a graph where all of the tensor calculations are done in
-eight bit, without having to convert to float.
-
-## What Representation is Used for Quantized Tensors?
-
-We approach converting floating-point arrays of numbers into eight-bit
-representations as a compression problem. We know that the weights and
-activation tensors in trained neural network models tend to have values that are
-distributed across comparatively small ranges (for example you might have -15 to
-+15 for weights, -500 to 1000 for activations on an image model, though the
-exact numbers will vary). We also know from experiment that neural nets tend to
-be very robust in the face of noise, and so the noise-like error produced by
-quantizing down to a small set of values will not hurt the precision of the
-overall results very much. We also want to pick a representation that's easy to
-perform calculations on, especially the large matrix multiplications that form
-the bulk of the work that's needed to run a model.
-
-These led us to pick a representation that has two floats to store the overall
-minimum and maximum values that are represented by the lowest and highest
-quantized value. Each entry in the quantized array represents a float value in
-that range, distributed linearly between the minimum and maximum. For example,
-if we have minimum = -10.0, and maximum = 30.0f, and an eight-bit array, here's
-what the quantized values represent:
+Provide this to the TensorFlow Lite Optimizing Converter (TOCO) to get a fully
+quantized TensorFLow Lite model:
 
 ```
-Quantized | Float
---------- | -----
-0         | -10.0
-255       | 30.0
-128       | 10.0
+bazel build tensorflow/contrib/lite/toco:toco && \
+  ./bazel-bin/third_party/tensorflow/contrib/lite/toco/toco \
+  --input_file=frozen_eval_graph.pb \
+  --output_file=tflite_model.tflite \
+  --input_format=TENSORFLOW_GRAPHDEF --output_format=TFLITE \
+  --inference_type=QUANTIZED_UINT8 \
+  --input_shape="1,224, 224,3" \
+  --input_array=input \
+  --output_array=outputs \
+  --std_value=127.5 --mean_value=127.5
 ```
 
-The advantages of this format are that it can represent arbitrary magnitudes of
-ranges, they don't have to be symmetrical, it can represent signed and unsigned
-values, and the linear spread makes doing multiplications straightforward. There
-are alternatives like [Song Han's code books](http://arxiv.org/pdf/1510.00149.pdf)
-that can use lower bit depths by non-linearly distributing the float values
-across the representation, but these tend to be more expensive to calculate on.
-
-The advantage of having a strong and clear definition of the quantized format is
-that it's always possible to convert back and forth from float for operations
-that aren't quantization-ready, or to inspect the tensors for debugging
-purposes. One implementation detail in TensorFlow that we're hoping to improve
-in the future is that the minimum and maximum float values need to be passed as
-separate tensors to the one holding the quantized values, so graphs can get a
-bit dense!
-
-The nice thing about the minimum and maximum ranges is that they can often be
-pre-calculated. Weight parameters are constants known at load time, so their
-ranges can also be stored as constants. We often know the ranges for inputs (for
-examples images are usually RGB values in the range 0.0 to 255.0), and many
-activation functions have known ranges too. This can avoid having to analyze the
-outputs of an operation to determine the range, which we need to do for math ops
-like convolution or matrix multiplication which produce 32-bit accumulated
-results from 8-bit inputs.
-
-## What's Next?
-
-We've found that we can get extremely good performance on mobile and embedded
-devices by using eight-bit arithmetic rather than floating-point. You can see
-the framework we use to optimize matrix multiplications at
-[gemmlowp](https://github.com/google/gemmlowp). We still need to apply all the
-lessons we've learned to the TensorFlow ops to get maximum performance on
-mobile, but we're actively working on that. Right now, this quantized
-implementation is a reasonably fast and accurate reference implementation that
-we're hoping will enable wider support for our eight-bit models on a wider
-variety of devices. We also hope that this demonstration will encourage the
-community to explore what's possible with low-precision neural networks.
+See the documentation for @{tf.contrib.quantize} and
+[TensorFlow Lite](/mobile/tflite/).
+
+## Quantized accuracy
+
+Fixed point [MobileNet](https://arxiv.org/abs/1704.0486) models are released with
+8-bit weights and activations. Using the rewriters, these models achieve the
+Top-1 accuracies listed in Table 1. For comparison, the floating point accuracies
+are listed for the same models. The code used to generate these models
+[is available](https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet_v1.md)
+along with links to all of the pretrained mobilenet_v1 models.
+
+<figure>
+  <table>
+    <tr>
+      <th>Image Size</th>
+      <th>Depth</th>
+      <th>Top-1 Accuracy:<br>Floating point</th>
+      <th>Top-1 Accuracy:<br>Fixed point: 8 bit weights and activations</th>
+    </tr>
+    <tr><td>128</td><td>0.25</td><td>0.415</td><td>0.399</td></tr>
+    <tr><td>128</td><td>0.5</td><td>0.563</td><td>0.549</td></tr>
+    <tr><td>128</td><td>0.75</td><td>0.621</td><td>0.598</td></tr>
+    <tr><td>128</td><td>1</td><td>0.652</td><td>0.64</td></tr>
+    <tr><td>160</td><td>0.25</td><td>0.455</td><td>0.435</td></tr>
+    <tr><td>160</td><td>0.5</td><td>0.591</td><td>0.577</td></tr>
+    <tr><td>160</td><td>0.75</td><td>0.653</td><td>0.639</td></tr>
+    <tr><td>160</td><td>1</td><td>0.68</td><td>0.673</td></tr>
+    <tr><td>192</td><td>0.25</td><td>0.477</td><td>0.458</td></tr>
+    <tr><td>192</td><td>0.5</td><td>0.617</td><td>0.604</td></tr>
+    <tr><td>192</td><td>0.75</td><td>0.672</td><td>0.662</td></tr>
+    <tr><td>192</td><td>1</td><td>0.7</td><td>0.69</td></tr>
+    <tr><td>224</td><td>0.25</td><td>0.498</td><td>0.482</td></tr>
+    <tr><td>224</td><td>0.5</td><td>0.633</td><td>0.622</td></tr>
+    <tr><td>224</td><td>0.75</td><td>0.684</td><td>0.679</td></tr>
+    <tr><td>224</td><td>1</td><td>0.709</td><td>0.697</td></tr>
+  </table>
+  <figcaption>
+    <b>Table 1</b>: MobileNet Top-1 accuracy on Imagenet Validation dataset.
+  </figcaption>
+</figure>
+
+## Representation for quantized tensors
+
+TensorFlow approaches the conversion of floating-point arrays of numbers into
+8-bit representations as a compression problem. Since the weights and activation
+tensors in trained neural network models tend to have values that are distributed
+across comparatively small ranges (for example, -15 to +15 for weights or -500 to
+1000 for image model activations). And since neural nets tend to be robust
+handling noise, the error introduced by quantizing to a small set of values
+maintains the precision of the overall results within an acceptable threshold. A
+chosen representation must perform fast calculations, especially the large matrix
+multiplications that comprise the bulk of the computations while running a model.
+
+This is represented with two floats that store the overall minimum and maximum
+values corresponding to the lowest and highest quantized value. Each entry in the
+quantized array represents a float value in that range, distributed linearly
+between the minimum and maximum. For example, with a minimum of -10.0 and maximum
+of 30.0f, and an 8-bit array, the quantized values represent the following:
+
+<figure>
+  <table>
+    <tr><th>Quantized</th><th>Float</th></tr>
+    <tr><td>0</td><td>-10.0</td></tr>
+    <tr><td>255</td><td>30.0</td></tr>
+    <tr><td>128</td><td>10.0</td></tr>
+  </table>
+  <figcaption>
+    <b>Table 2</b>: Example quantized value range
+  </figcaption>
+</figure>
+
+The advantages of this representation format are:
+
+* It efficiently represents an arbitrary magnitude of ranges.
+* The values don't have to be symmetrical.
+* The format represents both signed and unsigned values.
+* The linear spread makes multiplications straightforward.
+
+Alternative techniques use lower bit depths by non-linearly distributing the
+float values across the representation, but currently are more expensive in terms
+of computation time. (See Han et al.,
+[2016](https://arxiv.org/abs/1510.00149).)
+
+The advantage of having a clear definition of the quantized format is that it's
+always possible to convert back and forth from fixed-point to floating-point for
+operations that aren't quantization-ready, or to inspect the tensors for
+debugging.
diff --git a/performance/xla/operation_semantics.md b/performance/xla/operation_semantics.md
index 1e9b8b3..712d425 100644
--- a/performance/xla/operation_semantics.md
+++ b/performance/xla/operation_semantics.md
@@ -45,27 +45,30 @@ feature dimension in `operand`), the operation calculates the gradients with
 respect to `operand`, `offset` and `scale` across all the other dimensions. The
 `feature_index` must be a valid index for the feature dimension in `operand`.
 
-The three gradients are defined by the following formulas:
+The three gradients are defined by the following formulas (Assuming a
+4-dimensional tensor as `operand` and (l) is the index for feature dimension):
 
-\\( \nabla x = \nabla y * \gamma * \sqrt{\sigma^2+\epsilon} \\)
+\\( coef_l = \frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h (\nabla y_{ijkl} * (x_{ijkl} - \mu_l) / (\sigma^2_{l}+\epsilon)) \\)
 
-\\( \nabla \gamma = sum(\nabla y * (x - \mu) * \sqrt{\sigma^2 + \epsilon}) \\)
+\\( \nabla x_{ijkl} = \gamma_{l} * (1/\sqrt{\sigma^2_{l}+\epsilon}) * [\nabla y_{ijkl} - mean(\nabla y) - (x_{ijkl} - \mu_{l}) * coef_l] \\)
 
-\\( \nabla \beta = sum(\nabla y) \\)
+\\( \nabla \beta_l = \sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \nabla y_{ijkl} \\)
+
+\\( \nabla \gamma_l = \sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \nabla y_{ijkl} * ((x_{ijkl} - \mu_l) / \sqrt{\sigma^2_{l}+\epsilon}) \\)
 
 The inputs `mean` and `variance` represents moments value
 across batch and spatial dimensions.
 
 The output type is a tuple of three handles:
 
-|Outputs       | Type                    | Semantics                           |
-|------------- | ----------------------- | ------------------------------------|
-|`grad_operand`| `ComputationDataHandle` | gradient with respect to input      |
-:              :                         : `operand`                           :
-|`grad_scale`  | `ComputationDataHandle` | gradient with respect to input      |
-:              :                         : `scale`                             :
-|`grad_offset` | `ComputationDataHandle` | gradient with respect to input      |
-:              :                         : `offset`                            :
+|Outputs       | Type                    | Semantics                            |
+|------------- | ----------------------- | ------------------------------------ |
+|`grad_operand`| `ComputationDataHandle` | gradient with respect to input       |
+:              :                         : `operand` (\\( \nabla x\\))          :
+|`grad_scale`  | `ComputationDataHandle` | gradient with respect to input       |
+:              :                         : `scale` (\\( \nabla \gamma\\))       :
+|`grad_offset` | `ComputationDataHandle` | gradient with respect to input       |
+:              :                         : `offset`(\\( \nabla \beta\\))        :
 
 
 ## BatchNormInference
@@ -119,11 +122,11 @@ Normalizes an array across batch and spatial dimensions.
 | Arguments       | Type                    | Semantics                        |
 | --------------- | ----------------------- | -------------------------------- |
 | `operand`       | `ComputationDataHandle` | n dimensional array to be        |
-:                 :                         : normalized                       :
+:                 :                         : normalized (x)                   :
 | `scale`         | `ComputationDataHandle` | 1 dimensional array              |
 :                 :                         : (\\(\gamma\\))                   :
 | `offset`        | `ComputationDataHandle` | 1 dimensional array              |
-:                 :                         : (\\(\beta\\ )                    :
+:                 :                         : (\\(\beta\\))                    :
 | `epsilon`       | `float`                 | Epsilon value (\\(\epsilon\\))   |
 | `feature_index` | `int64`                 | Index to feature dimension       |
 :                 :                         : in `operand`                     :
@@ -135,8 +138,8 @@ element in `operand`. The `feature_index` must be a valid index for the feature
 dimension in `operand`.
 
 The algorithm goes as follows for each batch in `operand` \\(x\\) that
-contains `m` elements with `w` and `h` as the size of spatial dimensions (
-assuming `operand` is an 4 dimensional array):
+contains `m` elements with `w` and `h` as the size of spatial dimensions
+(assuming `operand` is an 4 dimensional array):
 
 - Calculates batch mean \\(\mu_l\\) for each feature `l` in feature dimension:
 \\(\mu_l=\frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h x_{ijkl}\\)
@@ -170,7 +173,7 @@ Similar to a `tf.bitcast` in TensorFlow, performs an element-wise bitcast
 operation from a data shape to a target shape. The dimensions must match, and
 the conversion is an element-wise one; e.g. `s32` elements become `f32` elements
 via bitcast routine. Bitcast is implemented as a low-level cast, so machines
-with different floating point representations will give different results.
+with different floating-point representations will give different results.
 
 <b> `BitcastConvertType(operand, new_element_type)` </b>
 
@@ -252,7 +255,7 @@ Clamps an operand to within the range between a minimum and maximum value.
 Given an operand and minimum and maximum values, returns the operand if it is in
 the range between the minimum and maximum, else returns the minimum value if the
 operand is below this range or the maximum value if the operand is above this
-range.  That is, `clamp(a, x, b) =  max(min(a, x), b)`.
+range.  That is, `clamp(a, x, b) =  min(max(a, x), b)`.
 
 All three arrays must be the same shape. Alternately, as a restricted form of
 [broadcasting](broadcasting.md), `min` and/or `max` can be a scalar of type `T`.
@@ -351,7 +354,7 @@ each other) and contains the arguments in the order that they were specified.
 :             :                         : concatenated between the `operands`. :
 
 With the exception of `dimension` all dimensions must be the same. This is
-because XLA does not support "ragged" arrays Also note that rank-0 values
+because XLA does not support "ragged" arrays. Also note that rank-0 values
 cannot be concatenated (as it's impossible to name the dimension along which the
 concatenation occurs).
 
@@ -440,11 +443,13 @@ area and a computation is performed for each possible position of the window.
 | `lhs`            | `ComputationDataHandle` | rank n+2 array of inputs      |
 | `rhs`            | `ComputationDataHandle` | rank n+2 array of kernel      |
 :                  :                         : weights                       :
-| `window_strides` | `ArraySlice<int64>`     | n-d array of kernel strides   |
-| `padding`        | `ArraySlice<pair<int64, | n-d array of (low, high)      |
+| `window_strides` | `ArraySlice<int64>`     | size n array of kernel strides|
+| `padding`        | `ArraySlice<pair<int64, | size n array of (low, high)   |
 :                  : int64>>`                : padding                       :
-| `lhs_dilation`   | `ArraySlice<int64>`     | n-d lhs dilation factor array |
-| `rhs_dilation`   | `ArraySlice<int64>`     | n-d rhs dilation factor array |
+| `lhs_dilation`   | `ArraySlice<int64>`     | size n lhs dilation factor    |
+:                  :                         : array                         |
+| `rhs_dilation`   | `ArraySlice<int64>`     | size n rhs dilation factor
+:                  :                         : array                         |
 
 Let n be the number of spatial dimensions. The `lhs` argument is a rank n+2
 array describing the base area. This is called the input, even though of course
@@ -468,7 +473,7 @@ filter/kernel/window. The dimensions are, in this order:
     window that moves across the base area.
 
 The `window_strides` argument specifies the stride of the convolutional window
-in the spatial dimensions. For example, if the stride in a the first spatial
+in the spatial dimensions. For example, if the stride in the first spatial
 dimension is 3, then the window can only be placed at coordinates where the
 first spatial index is divisible by 3.
 
@@ -717,6 +722,7 @@ in 'dimension_numbers'.
 Associated contracting dimension numbers from the 'lhs' and 'rhs' do not need
 to be the same, but must be listed in the same order in both
 'lhs/rhs_contracting_dimensions' arrays and have the same dimension sizes.
+There must be exactly one contracting dimension on both 'lhs' and 'rhs'.
 
 Example with contracting dimension numbers:
 
@@ -736,8 +742,9 @@ DotGeneral(lhs, rhs, dnums) -> { {6.0, 12.0},
 ```
 
 Associated batch dimension numbers from the 'lhs' and 'rhs' must have the same
-dimension number, must be listed in the same order in both arrays, and must
-have the same dimension sizes.
+dimension number, must be listed in the same order in both arrays, must
+have the same dimension sizes, and must be ordered before contracting and
+non-contracting/non-batch dimension numbers.
 
 Example with batch dimension numbers (batch size 2, 2x2 matrices):
 
@@ -769,6 +776,10 @@ DotGeneral(lhs, rhs, dnums) -> { { {1.0, 2.0},
 | [b0, m, k] `dot` [b0, k, n]         | [b0, m, n]        |  batch matmul    |
 | [b0, b1, m, k] `dot` [b0, b1, k, n] | [b0, b1, m, n]    |  batch matmul    |
 
+It follows that the resulting dimension number starts with the batch dimension,
+then the 'lhs' non-contracting/non-batch dimension, and finally the 'rhs'
+non-contracting/non-batch dimension.
+
 ## DynamicSlice
 
 See also
@@ -936,7 +947,7 @@ expand the rank of the lower-rank operand up to the rank of the higher-rank
 operand. `broadcast_dimensions` maps the dimensions of the lower-rank shape to
 the dimensions of the higher-rank shape. The unmapped dimensions of the expanded
 shape are filled with dimensions of size one. Degenerate-dimension broadcasting
-then broadcasts the shapes along these degenerate dimension to equalize the
+then broadcasts the shapes along these degenerate dimensions to equalize the
 shapes of both operands. The semantics are described in detail on the
 @{$broadcasting$broadcasting page}.
 
@@ -1021,6 +1032,213 @@ Arguments | Type                    | Semantics
 The function is applied to each element in the `operand` array, resulting in an
 array with the same shape. It is allowed for `operand` to be a scalar (rank 0).
 
+## Gather
+
+The XLA gather operation stitches together several slices (each slice at a
+potentially different runtime offset) of an input tensor into an output tensor.
+
+### General Semantics
+
+See also
+[`ComputationBuilder::Gather`](https://www.tensorflow.org/code/tensorflow/compiler/xla/client/computation_builder.h).
+For a more intuitive description, see the "Informal Description" section below.
+
+<b> `gather(operand, gather_indices, output_window_dims, elided_window_dims, window_bounds, gather_dims_to_operand_dims)` </b>
+
+|Arguments         | Type                    | Semantics                       |
+|----------------- | ----------------------- | --------------------------------|
+|`operand`         | `ComputationDataHandle` | The tensor we’re gathering      |
+:                  :                         : from.                           :
+|`gather_indices`  | `ComputationDataHandle` | Tensor containing the starting  |
+:                  :                         : indices of the slices we're     :
+:                  :                         : we're stitching together into   :
+:                  :                         : the output tensor.              :
+|`index_vector_dim`  | `int64`               | The dimension in                |
+:                  :                         : `gather_indices` that contains  :
+:                  :                         : the starting indices.           :
+|`output_window_dims` | `ArraySlice<int64>`  | The set of dimensions in the    |
+:                  :                         : output shape that are _window   :
+:                  :                         : dimensions_ (defined below).    :
+:                  :                         : Not all window dimensions may   :
+:                  :                         : be present in the output shape. :
+|`elided_window_dims` | `ArraySlice<int64>`  | The set of _window dimensions_  |
+:                  :            : that are not present in the output shape.    :
+:                  :            : `window_bounds[i]` must be `1` for all `i`   :
+:                  :            : in `elided_window_dims`.                     :
+|`window_bounds`   | `ArraySlice<int64>`    | `window_bounds[i]` is the bounds |
+:                  :            : for  window dimension `i`. This includes     :
+:                  :            : both the window dimensions that are          :
+:                  :            : explicitly part of the output shape (via     :
+:                  :            : `output_window_dims`) and the window         :
+:                  :            : dimensions that are elided (via              :
+:                  :            : `elided_window_dims`).                       :
+|`gather_dims_to_operand_dims` | `ArraySlice<int64>` | A dimension map (the    |
+:                  :            : array is interpreted as mapping `i` to       :
+:                  :            : `gather_dims_to_operand_dims[i]`)  from      :
+:                  :            : the gather indices in `gather_indices` to    :
+:                  :            : the operand index space.  It has to be       :
+:                  :            : one-to-one and total.                        :
+
+For every index `Out` in the output tensor, we compute two things (more
+precisely described later):
+
+  - An index into `gather_indices.rank` - `1` dimensions of `gather_indices`,
+    which gives us a starting index of a slice, _operand slice_, in the operand
+    tensor.  These `gather_indices.rank` - `1` dimensions are all the dimensions
+    in `gather_indices` except `index_vector_dim`.
+
+  - A _window index_ that has the same rank as the operand.  This index is
+    composed of the values in `Out` at dimensions `output_window_dims`, embedded
+    with zeroes according to `elided_window_dims`.
+
+The _window index_ is the relative index of the element in _operand slice_ that
+should be present in the output at index `Out`.
+
+The output is a tensor of rank `output_window_dims.size` + `gather_indices.rank`
+- `1`.  Additionally, as a shorthand, we define `output_gather_dims` of type
+`ArraySlice<int64>` as the set of dimensions in the output shape but not in
+`output_window_dims`, in ascending order.  E.g. if the output tensor has rank
+`5`, `output_window_dims` is {`2`, `4`} then `output_gather_dims` is {`0`, `1`,
+`3`}
+
+If `index_vector_dim` is equal to `gather_indices.rank` we implicitly
+consider `gather_indices` to have a trailing `1` dimension (i.e. if
+`gather_indices` was of shape `[6,7]` and `index_vector_dim` is `2` then
+we implicitly consider the shape of `gather_indices` to be `[6,7,1]`).
+
+The bounds for the output tensor along dimension `i` is computed as follows:
+
+  1. If `i` is present in `output_gather_dims` (i.e. is equal to
+     `output_gather_dims[k]` for some `k`) then we pick the corresponding
+     dimension bounds out of `gather_indices.shape`, skipping
+     `index_vector_dim` (i.e. pick `gather_indices.shape.dims`[`k`] if `k`
+     < `index_vector_dim` and `gather_indices.shape.dims`[`k`+`1`]
+     otherwise).
+  2. If `i` is present in `output_window_dims` (i.e. equal to
+     `output_window_dims`[`k`] for some `k`) then we pick the corresponding
+     bound out of `window_bounds` after accounting for `elided_window_dims`
+     (i.e. we pick `adjusted_window_bounds`[`k`] where `adjusted_window_bounds`
+     is `window_bounds` with the bounds at indices `elided_window_dims`
+     removed).
+
+The operand index `In` corresponding to an output index `Out` is computed as
+follows:
+
+  1. Let `G` = { `Out`[`k`] for `k` in `output_gather_dims` }.  Use `G` to slice
+     out vector `S` such that `S`[`i`] = `gather_indices`[Combine(`G`, `i`)]
+     where Combine(A, b) inserts b at position `index_vector_dim` into A.
+     Note that this is well defined even if `G` is empty -- if `G` is empty then
+     `S` = `gather_indices`.
+  2. Create an index, `S`<sub>`in`</sub>, into `operand` using `S` by
+     scattering `S` using the `gather_dims_to_operand_dims` map
+     (`S`<sub>`in`</sub> is the starting indices for _operand slice_ mentioned
+     above).  More precisely:
+       1. `S`<sub>`in`</sub>[`gather_dims_to_operand_dims`[`k`]] = `S`[`k`] if `k` <
+          `gather_dims_to_operand_dims.size`.
+       2. `S`<sub>`in`</sub>[`_`] = `0` otherwise.
+  3. Create an index `W`<sub>`in`</sub> into `operand` by scattering the indices
+     at the output window dimensions in `Out` according to
+     the `elided_window_dims` set (`W`<sub>`in`</sub> is the _window index_
+     mentioned above).  More precisely:
+       1. `W`<sub>`in`</sub>[`window_dims_to_operand_dims`(`k`)] = `Out`[`k`] if
+          `k` < `output_window_dims.size` (`window_dims_to_operand_dims` is
+          defined below).
+       2. `W`<sub>`in`</sub>[`_`] = `0` otherwise.
+  4. `In` is `W`<sub>`in`</sub> + `S`<sub>`in`</sub> where + is element-wise
+     addition.
+
+`window_dims_to_operand_dims` is the monotonic function with domain [`0`,
+`output_window_dims.size`) and range [`0`, `operand.rank`) \
+`elided_window_dims`.  So if, e.g., `output_window_dims.size` is `4`,
+`operand.rank` is `6` and `elided_window_dims` is {`0`, `2`} then
+`window_dims_to_operand_dims` is {`0`→`1`, `1`→`3`, `2`→`4`, `3`→`5`}.
+
+### Informal Description and Examples
+
+`index_vector_dim` is set to `gather_indices.rank` - `1` in all of the
+examples that follow.  More interesting values for `index_vector_dim`
+does not change the operation fundamentally, but makes the visual representation
+more cumbersome.
+
+To get an intuition on how all of the above fits together, let's look at an
+example that gathers 5 slices of shape `[8,6]` from a `[16,11]` tensor.  The
+position of a slice into the `[16,11]` tensor can be represented as an index
+vector of shape `S64[2]`, so the set of 5 positions can be represented as a
+`S64[5,2]` tensor.
+
+The behavior of the gather operation can then be depicted as an index
+transformation that takes [`G`,`W`<sub>`0`</sub>,`W`<sub>`1`</sub>], an index in
+the output shape, and maps it to an element in the input tensor in the following
+way:
+
+<div style="width:95%; margin:auto; margin-bottom:10px; margin-top:20px;">
+  <img style="width:100%" src="http://github.com/images/ops_xla_gather_0.svg">
+</div>
+
+We first select an (`X`,`Y`) vector from the gather indices tensor using `G`.
+The element in the output tensor at index
+[`G`,`W`<sub>`0`</sub>,`W`<sub>`1`</sub>] is then the element in the input
+tensor at index [`X`+`W`<sub>`0`</sub>,`Y`+`W`<sub>`1`</sub>].
+
+`window_bounds` is `[8,6]`, which decides the range of W<sub>`0`</sub> and
+W<sub>`1`</sub>, and this in turn decides the bounds of the slice.
+
+This gather operation acts as a batch dynamic slice with `G` as the batch
+dimension.
+
+The gather indices may be multidimensional.  For instance, a more general
+version of the example above using a "gather indices" tensor of shape `[4,5,2]`
+would translate indices like this:
+
+<div style="width:95%; margin:auto; margin-bottom:10px; margin-top:20px;">
+  <img style="width:100%" src="http://github.com/images/ops_xla_gather_1.svg">
+</div>
+
+Again, this acts as a batch dynamic slice `G`<sub>`0`</sub> and
+`G`<sub>`1`</sub> as the batch dimensions.  The window bounds are still `[8,6]`.
+
+The gather operation in XLA generalizes the informal semantics outlined above in
+the following ways:
+
+ 1. We can configure which dimensions in the output shape are the window
+    dimensions (dimensions containing `W`<sub>`0`</sub>, `W`<sub>`1`</sub> in
+    the last example).  The output gather dimensions (dimensions containing
+    `G`<sub>`0`</sub>, `G`<sub>`1`</sub> in the last example) are defined to be
+    the output dimensions that are not window dimensions.
+
+ 2. The number of output window dimensions explicitly present in the output
+    shape may be smaller than the input rank.  These "missing" dimensions, which
+    are listed explicitly as `elided_window_dims`, must have a window bound of
+    `1`.  Since they have a window bound of `1` the only valid index for them is
+    `0` and eliding them does not introduce ambiguity.
+
+ 3. The slice extracted from the "Gather Indices" tensor ((`X`, `Y`) in the last
+    example) may have fewer elements than the input tensor rank, and an explicit
+    mapping dictates how the index should be expanded to have the same rank as
+    the input.
+
+As a final example, we use (2) and (3) to implement `tf.gather_nd`:
+
+<div style="width:95%; margin:auto; margin-bottom:10px; margin-top:20px;">
+  <img style="width:100%" src="http://github.com/images/ops_xla_gather_2.svg">
+</div>
+
+`G`<sub>`0`</sub> and `G`<sub>`1`</sub> are used to slice out a starting index
+from the gather indices tensor as usual, except the starting index has only one
+element, `X`.  Similarly, there is only one output window index with the value
+`W`<sub>`0`</sub>.  However, before being used as indices into the input tensor,
+these are expanded in accordance to "Gather Index Mapping"
+(`gather_dims_to_operand_dims` in the formal description) and "Window Mapping"
+(`window_dims_to_operand_dims` in the formal description) into
+[`0`,`W`<sub>`0`</sub>] and [`X`,`0`] respectively, adding up to
+[`X`,`W`<sub>`0`</sub>].  In other words, the output index
+[`G`<sub>`0`</sub>,`G`<sub>`1`</sub>,`W`<sub>`0`</sub>] maps to the input index
+[`GatherIndices`[`G`<sub>`0`</sub>,`G`<sub>`1`</sub>,`0`],`X`] which gives us
+the semantics for `tf.gather_nd`.
+
+`window_bounds` for this case is `[1,11]`.  Intuitively this means that every
+index `X` in the gather indices tensor picks an entire row and the result is the
+concatenation of all these rows.
 
 ## GetTupleElement
 
@@ -1075,7 +1293,7 @@ result2 = while (condition, init = result1) {
 ```
 
 Nested tuple shapes are not supported. For an empty tuple shape, the Infeed
-operation is effectively a nop and proceeds without reading any data from the
+operation is effectively a no-op and proceeds without reading any data from the
 Infeed of the device.
 
 > Note: We plan to allow multiple Infeed operations without a total order, in
@@ -1138,7 +1356,7 @@ dimension.
 
 `PaddingConfig` is a repeated field of `PaddingConfigDimension`, which contains
 three fields for each dimension: `edge_padding_low`, `edge_padding_high`, and
-`interior_padding`. `edge_padding_low` and `edge_padding_high` specifies the
+`interior_padding`. `edge_padding_low` and `edge_padding_high` specify the
 amount of padding added at the low-end (next to index 0) and the high-end (next
 to the highest index) of each dimension respectively. The amount of edge padding
 can be negative -- the absolute value of negative padding indicates the number
@@ -1147,8 +1365,8 @@ the amount of padding added between any two elements in each dimension. Interior
 padding occurs logically before edge padding, so in the case of negative edge
 padding elements are removed from the interior-padded operand. This operation is
 a no-op if the edge padding pairs are all (0, 0) and the interior padding values
-are all 0. Figure below shows examples of different `edge_padding` and
-`interior_padding` values for a two dimensional array.
+are all 0. The figure below shows examples of different `edge_padding` and
+`interior_padding` values for a two-dimensional array.
 
 <div style="width:95%; margin:auto; margin-bottom:10px; margin-top:20px;">
   <img style="width:100%" src="https://www.tensorflow.org/images/ops_pad.png">
diff --git a/programmers_guide/datasets.md b/programmers_guide/datasets.md
index 9ede4ab..9ccdbde 100644
--- a/programmers_guide/datasets.md
+++ b/programmers_guide/datasets.md
@@ -18,11 +18,11 @@ The `tf.data` API introduces two new abstractions to TensorFlow:
   tensors representing the image data and a label. There are two distinct
   ways to create a dataset:
 
-  * Creating a **source** (e.g. `Dataset.from_tensor_slices()`) constructs a
+    * Creating a **source** (e.g. `Dataset.from_tensor_slices()`) constructs a
     dataset from
     one or more `tf.Tensor` objects.
 
-  * Applying a **transformation** (e.g. `Dataset.batch()`) constructs a dataset
+    * Applying a **transformation** (e.g. `Dataset.batch()`) constructs a dataset
     from one or more `tf.data.Dataset` objects.
 
 * A `tf.data.Iterator` provides the main way to extract elements from a
@@ -322,9 +322,39 @@ sess.run(iterator.initializer)
 next1, (next2, next3) = iterator.get_next()
 ```
 
-Note that evaluating *any* of `next1`, `next2`, or `next3` will advance the
-iterator for all components. A typical consumer of an iterator will include all
-components in a single expression.
+Note that `next1`, `next2`, and `next3` are tensors produced by the
+same op/node (created by `Iterator.get_next()`). Therefore,  evaluating *any* of
+these tensors will advance the iterator for all components. A typical consumer
+of an iterator will include all components in a single expression.
+
+### Saving iterator state
+
+The @{tf.contrib.data.make_saveable_from_iterator} function creates a
+`SaveableObject` from an iterator, which can be used to save and
+restore the current state of the iterator (and, effectively, the whole input
+pipeline). A saveable object thus created can be added to @{tf.train.Saver}
+variables list or the `tf.GraphKeys.SAVEABLE_OBJECTS` collection for saving and
+restoring in the same manner as a @{tf.Variable}. Refer to
+@{$saved_model$Saving and Restoring} for details on how to save and restore
+variables.
+
+```python
+# Create saveable object from iterator.
+saveable = tf.contrib.data.make_saveable_from_iterator(iterator)
+
+# Save the iterator state by adding it to the saveable objects collection.
+tf.add_to_collection(tf.GraphKeys.SAVEABLE_OBJECTS, saveable)
+saver = tf.train.Saver()
+
+with tf.Session() as sess:
+
+  if should_checkpoint:
+    saver.save(path_to_checkpoint)
+
+# Restore the iterator state.
+with tf.Session() as sess:
+  saver.restore(sess, path_to_checkpoint)
+```
 
 ## Reading input data
 
diff --git a/programmers_guide/debugger.md b/programmers_guide/debugger.md
index dbc4517..5fb1c2d 100644
--- a/programmers_guide/debugger.md
+++ b/programmers_guide/debugger.md
@@ -23,8 +23,13 @@ debuggers such as Python's `pdb` due to TensorFlow's computation-graph paradigm.
 > installed using `pip install <your_version>.whl`, however curses on Windows
 > may not work as reliably as curses on Linux or Mac.
 
-This tutorial demonstrates how to use the **tfdbg** command-line interface
-(CLI) to debug the appearance of [`nan`s](https://en.wikipedia.org/wiki/NaN)
+> NOTE: This guide focuses on the command-line interface (CLI) of tfdbg. For
+> guide on how to use the graphical user interface (GUI) of tfdbg, i.e., the
+> **TensorBoard Debugger Plugin**, please visit
+> [its README](https://github.com/tensorflow/tensorboard/blob/master/tensorboard/plugins/debugger/README.md).
+
+This tutorial demonstrates how to use the **tfdbg** CLI to debug the appearance
+of [`nan`s](https://en.wikipedia.org/wiki/NaN)
 and [`inf`s](https://en.wikipedia.org/wiki/Infinity), a frequently-encountered
 type of bug in TensorFlow model development.
 The following example is for users who use the low-level
@@ -214,7 +219,7 @@ navigate between these screens by clicking the `<--` and
 ### Other Features of the tfdbg CLI
 
 In addition to the commands listed above, the tfdbg CLI provides the following
-addditional features:
+additional features:
 
 *   To navigate through previous tfdbg commands, type in a few characters
     followed by the Up or Down arrow keys. tfdbg will show you the history of
@@ -806,3 +811,13 @@ sess.run(b)
 
 the constant-folding would not occur and `tfdbg` should show the intermediate
 tensor dumps.
+
+**Q**: Is there a GUI for tfdbg?
+
+**A**: Yes, the **TensorBoard Debugger Plugin** is the GUI of tfdbg.
+       It offers features such as inspection of the computation graph,
+       real-time visualization of tensor values, continuation to tensor
+       and conditional breakpoints, and tying tensors to their
+       graph-construction source code, all in the browser environment.
+       To get started, please visit
+       [its README](https://github.com/tensorflow/tensorboard/blob/master/tensorboard/plugins/debugger/README.md).
diff --git a/programmers_guide/faq.md b/programmers_guide/faq.md
index 70931f2..1548d43 100644
--- a/programmers_guide/faq.md
+++ b/programmers_guide/faq.md
@@ -159,8 +159,7 @@ available. These operations allow you to build sophisticated
 @{$reading_data$input pipelines}, at the cost of making the
 TensorFlow computation somewhat more complicated. See the how-to documentation
 for
-@{$reading_data#creating-threads-to-prefetch-using-queuerunner-objects$using
-`QueueRunner` objects to drive queues and readers}
+@{$reading_data#creating-threads-to-prefetch-using-queuerunner-objects$using `QueueRunner` objects to drive queues and readers}
 for more information on how to use them.
 
 ## Variables
diff --git a/programmers_guide/graphs.md b/programmers_guide/graphs.md
index 9049a5a..e69b717 100644
--- a/programmers_guide/graphs.md
+++ b/programmers_guide/graphs.md
@@ -210,9 +210,8 @@ with tf.device("/device:GPU:0"):
   # Operations created in this context will be pinned to the GPU.
   result = tf.matmul(weights, img)
 ```
-
-If you are deploying TensorFlow in a @{$deploy/distributed$typical distributed
-configuration}, you might specify the job name and task ID to place variables on
+If you are deploying TensorFlow in a @{$deploy/distributed$typical distributed configuration},
+you might specify the job name and task ID to place variables on
 a task in the parameter server job (`"/job:ps"`), and the other operations on
 task in the worker job (`"/job:worker"`):
 
@@ -336,20 +335,20 @@ described below.
   controls the behavior of the session. For example, some of the configuration
   options include:
 
-  * `allow_soft_placement`. Set this to `True` to enable a "soft" device
+    * `allow_soft_placement`. Set this to `True` to enable a "soft" device
     placement algorithm, which ignores @{tf.device} annotations that attempt
     to place CPU-only operations on a GPU device, and places them on the CPU
     instead.
 
-  * `cluster_def`. When using distributed TensorFlow, this option allows you
+    * `cluster_def`. When using distributed TensorFlow, this option allows you
     to specify what machines to use in the computation, and provide a mapping
     between job names, task indices, and network addresses. See
     @{tf.train.ClusterSpec.as_cluster_def} for details.
 
-  * `graph_options.optimizer_options`. Provides control over the optimizations
+    * `graph_options.optimizer_options`. Provides control over the optimizations
     that TensorFlow performs on your graph before executing it.
 
-  * `gpu_options.allow_growth`. Set this to `True` to change the GPU memory
+    * `gpu_options.allow_growth`. Set this to `True` to change the GPU memory
     allocator so that it gradually increases the amount of memory allocated,
     rather than allocating most of the memory at startup.
 
diff --git a/programmers_guide/index.md b/programmers_guide/index.md
index d45e666..e8c2fa6 100644
--- a/programmers_guide/index.md
+++ b/programmers_guide/index.md
@@ -13,7 +13,7 @@ works. The units are as follows:
 ## Low Level APIs
 
   * @{$programmers_guide/low_level_intro}, which introduces the
-    basics of how you can to use TensorFlow outside of the high Level APIs.
+    basics of how you can use TensorFlow outside of the high Level APIs.
   * @{$programmers_guide/tensors}, which explains how to create,
     manipulate, and access Tensors--the fundamental object in TensorFlow.
   * @{$programmers_guide/variables}, which details how
@@ -30,8 +30,12 @@ works. The units are as follows:
     can still be helpful.
   * @{$programmers_guide/saved_model}, which
     explains how to save and restore variables and models.
+
+## Accelerators
+
   * @{$using_gpu} explains how TensorFlow assigns operations to
     devices and how you can change the arrangement manually.
+  * @{$using_tpu} explains how to modify `Estimator` programs to run on a TPU.
 
 
 ## ML Concepts
diff --git a/programmers_guide/low_level_intro.md b/programmers_guide/low_level_intro.md
index 8f6d3fb..05709ad 100644
--- a/programmers_guide/low_level_intro.md
+++ b/programmers_guide/low_level_intro.md
@@ -286,6 +286,23 @@ while True:
     break
 ```
 
+If the `Dataset` depends on stateful operations you may need to
+initialize the iterator before using it, as shown below:
+
+``` python
+r = tf.random_normal([10,3])
+dataset = tf.data.Dataset.from_tensor_slices(r)
+iterator = dataset.make_initializable_iterator()
+next_row = iterator.get_next()
+
+sess.run(iterator.initializer)
+while True:
+  try:
+    print(sess.run(next_row))
+  except tf.errors.OutOfRangeError:
+    break
+```
+
 For more details on Datasets and Iterators see: @{$programmers_guide/datasets}.
 
 ## Layers
@@ -295,7 +312,7 @@ the same input.  @{tf.layers$Layers} are the preferred way to add trainable
 parameters to a graph.
 
 Layers package together both the variables and the operations that act
-on them, . For example a
+on them. For example a
 [densely-connected layer](https://developers.google.com/machine-learning/glossary/#fully_connected_layer)
 performs a weighted sum across all inputs
 for each output and applies an optional
@@ -478,7 +495,7 @@ good. Here's what we got; your own output will almost certainly differ:
  [ 0.10527515]]
 ```
 
-### loss
+### Loss
 
 To optimize a model, you first need to define the loss. We'll use the mean
 square error, a standard loss for regression problems.
@@ -504,7 +521,7 @@ TensorFlow provides
 [**optimizers**](https://developers.google.com/machine-learning/glossary/#optimizer)
 implementing standard optimization algorithms. These are implemented as
 sub-classes of @{tf.train.Optimizer}. They incrementally change each
-variable in order to minimizethe loss. The simplest optimization algorithm is
+variable in order to minimize the loss. The simplest optimization algorithm is
 [**gradient descent**](https://developers.google.com/machine-learning/glossary/#gradient_descent),
 implemented by @{tf.train.GradientDescentOptimizer}. It modifies each
 variable according to the magnitude of the derivative of loss with respect to
diff --git a/programmers_guide/saved_model.md b/programmers_guide/saved_model.md
index f27a658..5dfe6ef 100644
--- a/programmers_guide/saved_model.md
+++ b/programmers_guide/saved_model.md
@@ -1,35 +1,33 @@
-# Saving and Restoring
+# Save and Restore
 
-This document explains how to save and restore
-@{$variables$variables} and models.
+The @{tf.train.Saver} class provides methods to save and restore models. The
+@{tf.saved_model.simple_save} function is an easy way to build a
+@{tf.saved_model$saved model} suitable for serving.
+[Estimators](/programmers_guide/estimators) automatically save and restore
+variables in the `model_dir`.
 
+## Save and restore variables
 
-## Saving and restoring variables
+TensorFlow @{$variables} are the best way to represent shared, persistent state
+manipulated by your program. The `tf.train.Saver` constructor adds `save` and
+`restore` ops to the graph for all, or a specified list, of the variables in the
+graph.  The `Saver` object provides methods to run these ops, specifying paths
+for the checkpoint files to write to or read from.
 
-A TensorFlow variable provides the best way to represent shared, persistent
-state manipulated by your program. (See @{$variables$Variables} for details.)
-This section explains how to save and restore variables.
-Note that Estimators automatically saves and restores variables
-(in the `model_dir`).
-
-The `tf.train.Saver` class provides methods for saving and restoring models.
-The `tf.train.Saver` constructor adds `save` and `restore` ops to the graph
-for all, or a specified list, of the variables in the graph.  The `Saver`
-object provides methods to run these ops, specifying paths for the checkpoint
-files to write to or read from.
-
-The saver will restore all variables already defined in your model. If you're
+`Saver` restores all variables already defined in your model. If you're
 loading a model without knowing how to build its graph (for example, if you're
 writing a generic program to load models), then read the
 [Overview of saving and restoring models](#models) section
 later in this document.
 
-TensorFlow saves variables in binary **checkpoint files** that,
-roughly speaking, map variable names to tensor values.
-
+TensorFlow saves variables in binary *checkpoint files* that map variable
+names to tensor values.
 
+Caution: TensorFlow model files are code. Be careful with untrusted code.
+See [Using TensorFlow Securely](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md)
+for details.
 
-### Saving variables
+### Save variables
 
 Create a `Saver` with `tf.train.Saver()` to manage all variables in the
 model. For example, the following snippet demonstrates how to call the
@@ -61,9 +59,7 @@ with tf.Session() as sess:
   print("Model saved in path: %s" % save_path)
 ```
 
-
-
-### Restoring variables
+### Restore variables
 
 The `tf.train.Saver` object not only saves variables to checkpoint files, it
 also restores variables. Note that when you restore variables you do not have
@@ -92,14 +88,11 @@ with tf.Session() as sess:
   print("v2 : %s" % v2.eval())
 ```
 
-Notes:
+Note: There is not a physical file called `/tmp/model.ckpt`. It is the *prefix* of
+filenames created for the checkpoint. Users only interact with the prefix
+instead of physical checkpoint files.
 
-*  There is not a physical file called "/tmp/model.ckpt". It is the **prefix**
-   of filenames created for the checkpoint. Users only interact with the
-   prefix instead of physical checkpoint files.
-
-
-### Choosing which variables to save and restore
+### Choose variables to save and restore
 
 If you do not pass any arguments to `tf.train.Saver()`, the saver handles all
 variables in the graph.  Each variable is saved under the name that was passed
@@ -198,29 +191,42 @@ chkp.print_tensors_in_checkpoint_file("/tmp/model.ckpt", tensor_name='v2', all_t
 
 
 <a name="models"></a>
-## Overview of saving and restoring models
+## Save and restore models
+
+Use `SavedModel` to save and load your model—variables, the graph, and the
+graph's metadata. This is a language-neutral, recoverable, hermetic
+serialization format that enables higher-level systems and tools to produce,
+consume, and transform TensorFlow models. TensorFlow provides several ways to
+interact with `SavedModel`, including the @{tf.saved_model} APIs,
+@{tf.estimator.Estimator}, and a command-line interface.
 
-When you want to save and load variables, the graph, and the
-graph's metadata--basically, when you want to save or restore
-your model--we recommend using SavedModel.
-**SavedModel** is a language-neutral, recoverable, hermetic
-serialization format.  SavedModel enables higher-level systems
-and tools to produce, consume, and transform TensorFlow models.
-TensorFlow provides several mechanisms for interacting with
-SavedModel, including tf.saved_model APIs, Estimator APIs and a CLI.
 
+## Build and load a SavedModel
 
-## APIs to build and load a SavedModel
+### Simple save
 
-This section focuses on the APIs for building and loading a SavedModel,
-particularly when using lower-level TensorFlow APIs.
+The easiest way to create a `SavedModel` is to use the @{tf.saved_model.simple_save}
+function:
 
+```python
+simple_save(session,
+            export_dir,
+            inputs={"x": x, "y": y},
+            outputs={"z": z})
+```
 
-### Building a SavedModel
+This configures the `SavedModel` so it can be loaded by
+[TensorFlow serving](/serving/serving_basic) and supports the
+[Predict API](https://github.com/tensorflow/serving/blob/master/tensorflow_serving/apis/predict.proto).
+To access the classify, regress, or multi-inference APIs, use the manual
+`SavedModel` builder APIs or an @{tf.estimator.Estimator}.
 
-We provide a Python implementation of the SavedModel
-@{tf.saved_model.builder$builder}.
-The `SavedModelBuilder` class provides functionality to
+### Manually build a SavedModel
+
+If your use case isn't covered by @{tf.saved_model.simple_save}, use the manual
+@{tf.saved_model.builder$builder APIs} to create a `SavedModel`.
+
+The @{tf.saved_model.builder.SavedModelBuilder} class provides functionality to
 save multiple `MetaGraphDef`s.  A **MetaGraph** is a dataflow graph, plus
 its associated variables, assets, and signatures.  A **`MetaGraphDef`**
 is the protocol buffer representation of a MetaGraph.  A **signature** is
@@ -261,7 +267,7 @@ builder.save()
 ```
 
 
-### Loading a SavedModel in Python
+### Load a SavedModel in Python
 
 The Python version of the SavedModel
 @{tf.saved_model.loader$loader}
@@ -285,7 +291,7 @@ with tf.Session(graph=tf.Graph()) as sess:
 ```
 
 
-### Loading a SavedModel in C++
+### Load a SavedModel in C++
 
 The C++ version of the SavedModel
 [loader](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/cc/saved_model/loader.h)
@@ -303,7 +309,7 @@ LoadSavedModel(session_options, run_options, export_dir, {kSavedModelTagTrain},
                &bundle);
 ```
 
-### Loading and Serving a SavedModel in TensorFlow Serving
+### Load and serve a SavedModel in TensorFlow serving
 
 You can easily load and serve a SavedModel with the TensorFlow Serving Model
 Server binary. See [instructions](https://www.tensorflow.org/serving/setup#installing_using_apt-get)
@@ -371,7 +377,7 @@ SavedModel format. This section explains how to:
 * Serve the model from a local server and request predictions.
 
 
-### Preparing serving inputs
+### Prepare serving inputs
 
 During training, an @{$premade_estimators#input_fn$`input_fn()`} ingests data
 and prepares it for use by the model.  At serving time, similarly, a
@@ -445,7 +451,7 @@ to expect and how to map them to your model's expected inputs.
 By contrast, the *output* portion of the signature is determined by the model.
 
 
-### Performing the export
+### Perform the export
 
 To export your trained Estimator, call
 @{tf.estimator.Estimator.export_savedmodel} with the export base path and
@@ -468,7 +474,7 @@ Session.
 > Note: It is your responsibility to garbage-collect old exports.
 > Otherwise, successive exports will accumulate under `export_dir_base`.
 
-### Specifying the outputs of a custom model
+### Specify the outputs of a custom model
 
 When writing a custom `model_fn`, you must populate the `export_outputs` element
 of the @{tf.estimator.EstimatorSpec} return value. This is a dict of
@@ -500,7 +506,7 @@ indicating which `SignatureDef` will be served when an inference request
 does not specify one.
 
 
-### Serving the exported model locally
+### Serve the exported model locally
 
 For local deployment, you can serve your model using
 [TensorFlow Serving](https://github.com/tensorflow/serving), an open-source project that loads a
@@ -519,7 +525,7 @@ bazel-bin/tensorflow_serving/model_servers/tensorflow_model_server --port=9000 -
 Now you have a server listening for inference requests via gRPC on port 9000!
 
 
-### Requesting predictions from a local server
+### Request predictions from a local server
 
 The server responds to gRPC requests according to the
 [PredictionService](https://github.com/tensorflow/serving/blob/master/tensorflow_serving/apis/prediction_service.proto#L15)
@@ -612,7 +618,7 @@ passing in sample inputs in various formats (for example, Python
 expressions) and then fetching the output.
 
 
-### Installing the SavedModel CLI
+### Install the SavedModel CLI
 
 Broadly speaking, you can install TensorFlow in either of the following
 two ways:
@@ -694,15 +700,15 @@ executing the computation graph later. For example:
 $ saved_model_cli show --dir \
 /tmp/saved_model_dir --tag_set serve --signature_def serving_default
 The given SavedModel SignatureDef contains the following input(s):
-inputs['x'] tensor_info:
-    dtype: DT_FLOAT
-    shape: (-1, 1)
-    name: x:0
+  inputs['x'] tensor_info:
+      dtype: DT_FLOAT
+      shape: (-1, 1)
+      name: x:0
 The given SavedModel SignatureDef contains the following output(s):
-outputs['y'] tensor_info:
-    dtype: DT_FLOAT
-    shape: (-1, 1)
-    name: y:0
+  outputs['y'] tensor_info:
+      dtype: DT_FLOAT
+      shape: (-1, 1)
+      name: y:0
 Method name is: tensorflow/serving/predict
 ```
 
@@ -714,32 +720,32 @@ $ saved_model_cli show --dir /tmp/saved_model_dir --all
 MetaGraphDef with tag-set: 'serve' contains the following SignatureDefs:
 
 signature_def['classify_x2_to_y3']:
-The given SavedModel SignatureDef contains the following input(s):
-inputs['inputs'] tensor_info:
-    dtype: DT_FLOAT
-    shape: (-1, 1)
-    name: x2:0
-The given SavedModel SignatureDef contains the following output(s):
-outputs['scores'] tensor_info:
-    dtype: DT_FLOAT
-    shape: (-1, 1)
-    name: y3:0
-Method name is: tensorflow/serving/classify
+  The given SavedModel SignatureDef contains the following input(s):
+    inputs['inputs'] tensor_info:
+        dtype: DT_FLOAT
+        shape: (-1, 1)
+        name: x2:0
+  The given SavedModel SignatureDef contains the following output(s):
+    outputs['scores'] tensor_info:
+        dtype: DT_FLOAT
+        shape: (-1, 1)
+        name: y3:0
+  Method name is: tensorflow/serving/classify
 
 ...
 
 signature_def['serving_default']:
-The given SavedModel SignatureDef contains the following input(s):
-inputs['x'] tensor_info:
-    dtype: DT_FLOAT
-    shape: (-1, 1)
-    name: x:0
-The given SavedModel SignatureDef contains the following output(s):
-outputs['y'] tensor_info:
-    dtype: DT_FLOAT
-    shape: (-1, 1)
-    name: y:0
-Method name is: tensorflow/serving/predict
+  The given SavedModel SignatureDef contains the following input(s):
+    inputs['x'] tensor_info:
+        dtype: DT_FLOAT
+        shape: (-1, 1)
+        name: x:0
+  The given SavedModel SignatureDef contains the following output(s):
+    outputs['y'] tensor_info:
+        dtype: DT_FLOAT
+        shape: (-1, 1)
+        name: y:0
+  Method name is: tensorflow/serving/predict
 ```
 
 
@@ -839,7 +845,7 @@ For example:
 `<input_key>=[{"age":[22,24],"education":["BS","MS"]}]`
 ```
 
-#### Save Output
+#### Save output
 
 By default, the SavedModel CLI writes output to stdout. If a directory is
 passed to `--outdir` option, the outputs will be saved as npy files named after
@@ -848,7 +854,7 @@ output tensor keys under the given directory.
 Use `--overwrite` to overwrite existing output files.
 
 
-#### TensorFlow Debugger (tfdbg) Integration
+#### TensorFlow debugger (tfdbg) integration
 
 If `--tf_debug` option is set, the SavedModel CLI will use the
 TensorFlow Debugger (tfdbg) to watch the intermediate Tensors and runtime
@@ -955,6 +961,3 @@ of checkpoints and assets:
 
 Each graph is associated with a specific set of tags, which enables
 identification during a load or restore operation.
-
-
-
diff --git a/programmers_guide/summaries_and_tensorboard.md b/programmers_guide/summaries_and_tensorboard.md
index 05dfdfd..79280d2 100644
--- a/programmers_guide/summaries_and_tensorboard.md
+++ b/programmers_guide/summaries_and_tensorboard.md
@@ -16,10 +16,17 @@ TensorBoard is fully configured, it looks like this:
   </iframe>
 </div>
 
-This tutorial is intended to get you started with simple TensorBoard usage.
-There are other resources available as well! The [TensorBoard's GitHub](https://github.com/tensorflow/tensorboard)
-has a lot more information on TensorBoard usage, including tips & tricks, and
-debugging information.
+This 30-minute tutorial is intended to get you started with simple TensorBoard
+usage. It assumes a basic understanding of TensorFlow.
+
+There are other resources available as well! The [TensorBoard GitHub](https://github.com/tensorflow/tensorboard)
+has a lot more information on using individual dashboards within TensorBoard
+including tips & tricks and debugging information.
+
+## Setup
+
+[Install TensorFlow](https://www.tensorflow.org/install/). Installing TensorFlow
+via pip should also automatically install TensorBoard.
 
 ## Serializing the data
 
@@ -214,4 +221,5 @@ corner. Each tab represents a set of serialized data that can be visualized.
 For in depth information on how to use the *graph* tab to visualize your graph,
 see @{$graph_viz$TensorBoard: Graph Visualization}.
 
-For more usage information on TensorBoard in general, see the [TensorBoard's GitHub](https://github.com/tensorflow/tensorboard).
+For more usage information on TensorBoard in general, see the
+[TensorBoard GitHub](https://github.com/tensorflow/tensorboard).
diff --git a/programmers_guide/variables.md b/programmers_guide/variables.md
index 6425073..e8cf771 100644
--- a/programmers_guide/variables.md
+++ b/programmers_guide/variables.md
@@ -62,9 +62,10 @@ them. For this reason TensorFlow provides **collections**, which are named lists
 of tensors or other objects, such as `tf.Variable` instances.
 
 By default every `tf.Variable` gets placed in the following two collections:
+
  * `tf.GraphKeys.GLOBAL_VARIABLES` --- variables that can be shared across
-multiple devices,
- * `tf.GraphKeys.TRAINABLE_VARIABLES`--- variables for which TensorFlow will
+   multiple devices,
+ * `tf.GraphKeys.TRAINABLE_VARIABLES` --- variables for which TensorFlow will
    calculate gradients.
 
 If you don't want a variable to be trainable, add it to the
diff --git a/programmers_guide/version_compat.md b/programmers_guide/version_compat.md
index a28f138..e6613cc 100644
--- a/programmers_guide/version_compat.md
+++ b/programmers_guide/version_compat.md
@@ -60,7 +60,8 @@ patch versions.  The public APIs consist of
     * [`tensor_shape`](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/framework/tensor_shape.proto)
     * [`types`](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/framework/types.proto)
 
-## What is *not* covered {not_covered}
+<a name="not_covered"></a>
+## What is *not* covered
 
 Some API functions are explicitly marked as "experimental" and can change in
 backward incompatible ways between minor releases. These include:
diff --git a/tutorials/image_retraining.md b/tutorials/image_retraining.md
index df15bc0..246a420 100644
--- a/tutorials/image_retraining.md
+++ b/tutorials/image_retraining.md
@@ -349,31 +349,32 @@ results, but if you intend to deploy your model on mobile devices or other
 resource-constrained environments you may want to trade off a little accuracy
 for much smaller file sizes or faster speeds. To help with that, the
 [retrain.py script](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/examples/image_retraining/retrain.py)
-supports 32 different variations on the [Mobilenet architecture](https://research.googleblog.com/2017/06/mobilenets-open-source-models-for.html).
+supports different variations on the [Mobilenet architecture](https://research.googleblog.com/2017/06/mobilenets-open-source-models-for.html).
 
 These are a little less precise than Inception v3, but can result in far
-smaller file sizes (down to less than a megabyte) and can be many times faster
+smaller file sizes (a few megabytes) and can be many times faster
 to run. To train with one of these models, pass in the `--architecture` flag,
 for example:
 
 ```
 python tensorflow/examples/image_retraining/retrain.py \
-    --image_dir ~/flower_photos --architecture mobilenet_0.25_128_quantized
+    --image_dir ~/flower_photos --architecture mobilenet_0.25_128
 ```
 
-This will create a 941KB model file in `/tmp/output_graph.pb`, with 25% of the
-parameters of the full Mobilenet, taking 128x128 sized input images, and with
-its weights quantized down to eight bits on disk. You can choose '1.0', '0.75',
-'0.50', or '0.25' to control the number of weight parameters, and so the file
-size (and to some extent the speed), '224', '192', '160', or '128' for the input
-image size, with smaller sizes giving faster speeds, and an optional
-'_quantized' at the end to indicate whether the file should contain 8-bit or
-32-bit float weights.
+This will create a 1.9MB model file in `/tmp/output_graph.pb`, with only 25% of
+the number of neurons of the full Mobilenet, and trained to take 128x128 sized
+input images.
+
+You can choose '1.0', '0.75', '0.50', or '0.25' to control the number of
+neurons (activations of hidden layers); the number of weights (and hence to
+some extent the file size and speed) shrinks like the square of that fraction.
+You can choose '224', '192', '160', or '128' for the input image size,
+with smaller sizes giving faster speeds.
 
 The speed and size advantages come at a loss to accuracy of course, but for many
 purposes this isn't critical. They can also be somewhat offset with improved
 training data. For example, training with distortions allows me to get above 80%
-accuracy on the flower data set even with the 0.25/128/quantized graph above.
+accuracy on the flower data set even with the 0.25/128 graph above.
 
 If you're going to be using the Mobilenet models in label_image or your own
 programs, you'll need to feed in an image of the specified size converted to a
@@ -395,3 +396,9 @@ python tensorflow/examples/label_image/label_image.py \
 --input_mean=128 --input_std=128 \
 --image=$HOME/flower_photos/daisy/21652746_cc379e0eea_m.jpg
 ```
+
+For more information on deploying the retrained model to a mobile device, see
+the [codelab version](https://codelabs.developers.google.com/codelabs/tensorflow-for-poets/#0)
+of this tutorial, especially [part 2](https://codelabs.developers.google.com/codelabs/tensorflow-for-poets-2-tflite/#0), which describes
+[TensorFlow Lite](/mobile/tflite/) and the additional optimizations it offers
+(including quantization of model weights).
diff --git a/tutorials/index.md b/tutorials/index.md
index 8c697e4..af01d3e 100644
--- a/tutorials/index.md
+++ b/tutorials/index.md
@@ -10,7 +10,7 @@ these tutorials.
 
 These tutorials cover different aspects of image recognition:
 
-  * @{$layers}, which introduces convolutional neural networks (CNNs) and
+  * @{$layers$MNIST}, which introduces convolutional neural networks (CNNs) and
     demonstrates how to build a CNN in TensorFlow.
   * @{$image_recognition}, which introduces the field of image recognition and
     uses a pre-trained model (Inception) for recognizing images.
diff --git a/tutorials/layers.md b/tutorials/layers.md
index b898cbe..ee03f44 100644
--- a/tutorials/layers.md
+++ b/tutorials/layers.md
@@ -625,8 +625,7 @@ operation earlier when we generated the probabilities in `cnn_model_fn`.
 > Note: If you don't explicitly assign a name to an operation via the `name`
 > argument, TensorFlow will assign a default name. A couple easy ways to
 > discover the names applied to operations are to visualize your graph on
-> @{$graph_viz$TensorBoard}) or to enable the @{$debugger$TensorFlow Debugger
-> (tfdbg)}.
+> @{$graph_viz$TensorBoard}) or to enable the @{$debugger$TensorFlow Debugger (tfdbg)}.
 
 Next, we create the `LoggingTensorHook`, passing `tensors_to_log` to the
 `tensors` argument. We set `every_n_iter=50`, which specifies that probabilities
@@ -635,7 +634,7 @@ should be logged after every 50 steps of training.
 ### Train the Model
 
 Now we're ready to train our model, which we can do by creating `train_input_fn`
-ans calling `train()` on `mnist_classifier`. Add the following to `main()`:
+and calling `train()` on `mnist_classifier`. Add the following to `main()`:
 
 ```python
 # Train the model
diff --git a/tutorials/wide.md b/tutorials/wide.md
index dba6f54..bf6b9d6 100644
--- a/tutorials/wide.md
+++ b/tutorials/wide.md
@@ -82,7 +82,7 @@ Here's a list of columns available in the Census Income dataset:
 | hours_per_week | Continuous  | Hours worked per week.            |
 | native_country | Categorical | Country of origin of the          |
 :                :             : individual.                       :
-| income         | Categorical | ">50K" or "<=50K", meaning        |
+| income_bracket | Categorical | ">50K" or "<=50K", meaning        |
 :                :             : whether the person makes more     :
 :                :             : than $50,000 annually.            :
 
@@ -247,7 +247,7 @@ hours_per_week = tf.feature_column.numeric_column('hours_per_week')
 ### Making Continuous Features Categorical through Bucketization
 
 Sometimes the relationship between a continuous feature and the label is not
-linear. As an hypothetical example, a person's income may grow with age in the
+linear. As a hypothetical example, a person's income may grow with age in the
 early stage of one's career, then the growth may slow at some point, and finally
 the income decreases after retirement. In this scenario, using the raw `age` as
 a real-valued feature column might not be a good choice because the model can
@@ -361,6 +361,16 @@ The first line of the final output should be something like
 `accuracy: 0.83557522`, which means the accuracy is 83.6%. Feel free to try more
 features and transformations and see if you can do even better!
 
+After the model is evaluated, we can use the model to predict whether an individual has an annual income of over
+50,000 dollars given an individual's information input.
+```python
+  pred_iter = model.predict(input_fn=lambda: input_fn(FLAGS.test_data, 1, False, 1))
+  for pred in pred_iter:
+    print(pred['classes'])
+```
+
+The model prediction output would be like `[b'1']` or `[b'0']` which means whether corresponding individual has an annual income of over 50,000 dollars or not.
+
 If you'd like to see a working end-to-end example, you can download our
 [example code](https://github.com/tensorflow/models/tree/master/official/wide_deep/wide_deep.py)
 and set the `model_type` flag to `wide`.

From e1d75633a0cc84a2ae1fccd0496e146559e3079a Mon Sep 17 00:00:00 2001
From: Ding Xue-wen <xuewending1995@gmail.com>
Date: Fri, 20 Apr 2018 14:53:34 +0800
Subject: [PATCH 3/7] update

---
 about/uses.md                                 |  6 +-
 .../python/contrib.bayesflow.monte_carlo.md   | 36 +++----
 .../python/contrib.distributions.bijectors.md |  1 -
 api_guides/python/contrib.graph_editor.md     | 18 ++--
 api_guides/python/contrib.losses.md           | 28 +++---
 api_guides/python/io_ops.md                   |  4 +-
 api_guides/python/nn.md                       | 18 ++--
 api_guides/python/state_ops.md                |  2 +
 community/contributing.md                     | 49 ++++++++++
 community/documentation.md                    | 56 ++++-------
 community/groups.md                           | 17 ++++
 community/index.md                            | 96 ++++++++++++++++---
 community/leftnav_files                       |  5 +-
 community/lists.md                            | 51 ++++++++++
 community/security.md                         |  7 ++
 community/swift.md                            | 35 +++++++
 community/welcome.md                          | 69 -------------
 17 files changed, 324 insertions(+), 174 deletions(-)
 create mode 100644 community/contributing.md
 create mode 100644 community/groups.md
 create mode 100644 community/lists.md
 create mode 100644 community/security.md
 create mode 100644 community/swift.md
 delete mode 100644 community/welcome.md

diff --git a/about/uses.md b/about/uses.md
index d646880..d3db982 100644
--- a/about/uses.md
+++ b/about/uses.md
@@ -18,9 +18,9 @@ This section describes some of the current uses of the TensorFlow system.
 
 > If you are using TensorFlow for research, for education, or for production
 > usage in some product, we would love to add something about your usage here.
-> Please feel free to email us a brief description of how you're using
-> TensorFlow, or even better, send us a pull request to add an entry to this
-> file.
+> Please feel free to [email us](mailto:usecases@tensorflow.org) a brief
+> description of how you're using TensorFlow, or even better, send us a
+> pull request to add an entry to this file.
 
 * **Deep Speech**
 <ul>
diff --git a/api_guides/python/contrib.bayesflow.monte_carlo.md b/api_guides/python/contrib.bayesflow.monte_carlo.md
index 956dccb..f3db585 100644
--- a/api_guides/python/contrib.bayesflow.monte_carlo.md
+++ b/api_guides/python/contrib.bayesflow.monte_carlo.md
@@ -6,42 +6,42 @@ Monte Carlo integration and helpers.
 ## Background
 
 Monte Carlo integration refers to the practice of estimating an expectation with
-a sample mean.  For example, given random variable `Z in R^k` with density `p`,
+a sample mean.  For example, given random variable `Z in \\(R^k\\)` with density `p`,
 the expectation of function `f` can be approximated like:
 
 ```
-E_p[f(Z)] = \int f(z) p(z) dz
-          ~ S_n
-          := n^{-1} \sum_{i=1}^n f(z_i),  z_i iid samples from p.
+$$E_p[f(Z)] = \int f(z) p(z) dz$$
+$$          ~ S_n
+          := n^{-1} \sum_{i=1}^n f(z_i),  z_i\ iid\ samples\ from\ p.$$
 ```
 
-If `E_p[|f(Z)|] < infinity`, then `S_n --> E_p[f(Z)]` by the strong law of large
-numbers.  If `E_p[f(Z)^2] < infinity`, then `S_n` is asymptotically normal with
-variance `Var[f(Z)] / n`.
+If `\\(E_p[|f(Z)|] < infinity\\)`, then `\\(S_n\\) --> \\(E_p[f(Z)]\\)` by the strong law of large
+numbers.  If `\\(E_p[f(Z)^2] < infinity\\)`, then `\\(S_n\\)` is asymptotically normal with
+variance `\\(Var[f(Z)] / n\\)`.
 
 Practitioners of Bayesian statistics often find themselves wanting to estimate
-`E_p[f(Z)]` when the distribution `p` is known only up to a constant.  For
+`\\(E_p[f(Z)]\\)` when the distribution `p` is known only up to a constant.  For
 example, the joint distribution `p(z, x)` may be known, but the evidence
-`p(x) = \int p(z, x) dz` may be intractable.  In that case, a parameterized
-distribution family `q_lambda(z)` may be chosen, and the optimal `lambda` is the
-one minimizing the KL divergence between `q_lambda(z)` and
-`p(z | x)`.  We only know `p(z, x)`, but that is sufficient to find `lambda`.
+`\\(p(x) = \int p(z, x) dz\\)` may be intractable.  In that case, a parameterized
+distribution family `\\(q_\lambda(z)\\)` may be chosen, and the optimal `\\(\lambda\\)` is the
+one minimizing the KL divergence between `\\(q_\lambda(z)\\)` and
+`\\(p(z | x)\\)`.  We only know `p(z, x)`, but that is sufficient to find `\\(\lambda\\)`.
 
 
 ## Log-space evaluation and subtracting the maximum
 
 Care must be taken when the random variable lives in a high dimensional space.
-For example, the naive importance sample estimate `E_q[f(Z) p(Z) / q(Z)]`
-involves the ratio of two terms `p(Z) / q(Z)`, each of which must have tails
-dropping off faster than `O(|z|^{-(k + 1)})` in order to have finite integral.
+For example, the naive importance sample estimate `\\(E_q[f(Z) p(Z) / q(Z)]\\)`
+involves the ratio of two terms `\\(p(Z) / q(Z)\\)`, each of which must have tails
+dropping off faster than `\\(O(|z|^{-(k + 1)})\\)` in order to have finite integral.
 This ratio would often be zero or infinity up to numerical precision.
 
 For that reason, we write
 
 ```
-Log E_q[ f(Z) p(Z) / q(Z) ]
-   = Log E_q[ exp{Log[f(Z)] + Log[p(Z)] - Log[q(Z)] - C} ] + C,  where
-C := Max[ Log[f(Z)] + Log[p(Z)] - Log[q(Z)] ].
+$$Log E_q[ f(Z) p(Z) / q(Z) ]$$
+$$   = Log E_q[ \exp\{Log[f(Z)] + Log[p(Z)] - Log[q(Z)] - C\} ] + C,$$  where
+$$C := Max[ Log[f(Z)] + Log[p(Z)] - Log[q(Z)] ].$$
 ```
 
 The maximum value of the exponentiated term will be 0.0, and the expectation
diff --git a/api_guides/python/contrib.distributions.bijectors.md b/api_guides/python/contrib.distributions.bijectors.md
index 0ce187b..e169897 100644
--- a/api_guides/python/contrib.distributions.bijectors.md
+++ b/api_guides/python/contrib.distributions.bijectors.md
@@ -28,6 +28,5 @@ To apply a `Bijector`, use `distributions.TransformedDistribution`.
 *   @{tf.contrib.distributions.bijectors.Inline}
 *   @{tf.contrib.distributions.bijectors.Invert}
 *   @{tf.contrib.distributions.bijectors.PowerTransform}
-*   @{tf.contrib.distributions.bijectors.SigmoidCentered}
 *   @{tf.contrib.distributions.bijectors.SoftmaxCentered}
 *   @{tf.contrib.distributions.bijectors.Softplus}
diff --git a/api_guides/python/contrib.graph_editor.md b/api_guides/python/contrib.graph_editor.md
index de4f126..20fe88a 100644
--- a/api_guides/python/contrib.graph_editor.md
+++ b/api_guides/python/contrib.graph_editor.md
@@ -61,21 +61,21 @@ A subgraph can be created in several ways:
 
 * using a list of ops:
 
-```python
-my_sgv = ge.sgv(ops)
-```
+  ```python
+  my_sgv = ge.sgv(ops)
+  ```
 
 * from a name scope:
 
-```python
-my_sgv = ge.sgv_scope("foo/bar", graph=tf.get_default_graph())
-```
+  ```python
+  my_sgv = ge.sgv_scope("foo/bar", graph=tf.get_default_graph())
+  ```
 
 * using regular expression:
 
-```python
-my_sgv = ge.sgv("foo/.*/.*read$", graph=tf.get_default_graph())
-```
+  ```python
+  my_sgv = ge.sgv("foo/.*/.*read$", graph=tf.get_default_graph())
+  ```
 
 Note that the Graph Editor is meant to manipulate several graphs at the same
 time, typically during transform or copy operation. For that reason,
diff --git a/api_guides/python/contrib.losses.md b/api_guides/python/contrib.losses.md
index d7f8626..8b74422 100644
--- a/api_guides/python/contrib.losses.md
+++ b/api_guides/python/contrib.losses.md
@@ -107,19 +107,19 @@ weighted average over the individual prediction errors:
   loss = tf.contrib.losses.mean_squared_error(predictions, depths, weight)
 ```
 
-@{tf.contrib.losses.absolute_difference}
-@{tf.contrib.losses.add_loss}
-@{tf.contrib.losses.hinge_loss}
-@{tf.contrib.losses.compute_weighted_loss}
-@{tf.contrib.losses.cosine_distance}
-@{tf.contrib.losses.get_losses}
-@{tf.contrib.losses.get_regularization_losses}
-@{tf.contrib.losses.get_total_loss}
-@{tf.contrib.losses.log_loss}
-@{tf.contrib.losses.mean_pairwise_squared_error}
-@{tf.contrib.losses.mean_squared_error}
-@{tf.contrib.losses.sigmoid_cross_entropy}
-@{tf.contrib.losses.softmax_cross_entropy}
-@{tf.contrib.losses.sparse_softmax_cross_entropy}
+* @{tf.contrib.losses.absolute_difference}
+* @{tf.contrib.losses.add_loss}
+* @{tf.contrib.losses.hinge_loss}
+* @{tf.contrib.losses.compute_weighted_loss}
+* @{tf.contrib.losses.cosine_distance}
+* @{tf.contrib.losses.get_losses}
+* @{tf.contrib.losses.get_regularization_losses}
+* @{tf.contrib.losses.get_total_loss}
+* @{tf.contrib.losses.log_loss}
+* @{tf.contrib.losses.mean_pairwise_squared_error}
+* @{tf.contrib.losses.mean_squared_error}
+* @{tf.contrib.losses.sigmoid_cross_entropy}
+* @{tf.contrib.losses.softmax_cross_entropy}
+* @{tf.contrib.losses.sparse_softmax_cross_entropy}
 
 
diff --git a/api_guides/python/io_ops.md b/api_guides/python/io_ops.md
index 94cf0de..86b4b39 100644
--- a/api_guides/python/io_ops.md
+++ b/api_guides/python/io_ops.md
@@ -8,7 +8,7 @@ Note: Functions taking `Tensor` arguments can also take anything accepted by
 ## Placeholders
 
 TensorFlow provides a placeholder operation that must be fed with data
-on execution.  For more info, see the section on @{$reading_data#feeding$Feeding data}.
+on execution.  For more info, see the section on @{$reading_data#Feeding$Feeding data}.
 
 *   @{tf.placeholder}
 *   @{tf.placeholder_with_default}
@@ -42,7 +42,7 @@ formats into tensors.
 
 ### Example protocol buffer
 
-TensorFlow's @{$reading_data#standard-tensorflow-format$recommended format for training examples}
+TensorFlow's @{$reading_data#standard_tensorflow_format$recommended format for training examples}
 is serialized `Example` protocol buffers, [described
 here](https://www.tensorflow.org/code/tensorflow/core/example/example.proto).
 They contain `Features`, [described
diff --git a/api_guides/python/nn.md b/api_guides/python/nn.md
index 8e6fd1c..8d8daaa 100644
--- a/api_guides/python/nn.md
+++ b/api_guides/python/nn.md
@@ -89,7 +89,7 @@ bottom. Note that this is different from existing libraries such as cuDNN and
 Caffe, which explicitly specify the number of padded pixels and always pad the
 same number of pixels on both sides.
 
-For the `'VALID`' scheme, the output height and width are computed as:
+For the `'VALID'` scheme, the output height and width are computed as:
 
     out_height = ceil(float(in_height - filter_height + 1) / float(strides[1]))
     out_width  = ceil(float(in_width - filter_width + 1) / float(strides[2]))
@@ -98,10 +98,10 @@ and no padding is used.
 
 Given the output size and the padding, the output can be computed as
 
-    output[b, i, j, :] =
-        sum_{di, dj} input[b, strides[1] * i + di - pad_top,
-                           strides[2] * j + dj - pad_left, ...] *
-                     filter[di, dj, ...]
+$$    output[b, i, j, :] =
+        sum_{d_i, d_j} input[b, strides[1] * i + d_i - pad_{top},\
+                           strides[2] * j + d_j - pad_{left}, ...] *
+                     filter[d_i, d_j,\ ...]$$
 
 where any value outside the original input image region are considered zero (
 i.e. we pad zero values around the border of the image).
@@ -161,12 +161,12 @@ Morphological operators are non-linear filters used in image processing.
 ](https://en.wikipedia.org/wiki/Dilation_(morphology))
 is the max-sum counterpart of standard sum-product convolution:
 
-    output[b, y, x, c] =
+$$    output[b, y, x, c] =
         max_{dy, dx} input[b,
                            strides[1] * y + rates[1] * dy,
                            strides[2] * x + rates[2] * dx,
                            c] +
-                     filter[dy, dx, c]
+                     filter[dy, dx, c]$$
 
 The `filter` is usually called structuring function. Max-pooling is a special
 case of greyscale morphological dilation when the filter assumes all-zero
@@ -176,12 +176,12 @@ values (a.k.a. flat structuring function).
 ](https://en.wikipedia.org/wiki/Erosion_(morphology))
 is the min-sum counterpart of standard sum-product convolution:
 
-    output[b, y, x, c] =
+$$    output[b, y, x, c] =
         min_{dy, dx} input[b,
                            strides[1] * y - rates[1] * dy,
                            strides[2] * x - rates[2] * dx,
                            c] -
-                     filter[dy, dx, c]
+                     filter[dy, dx, c]$$
 
 Dilation and erosion are dual to each other. The dilation of the input signal
 `f` by the structuring signal `g` is equal to the negation of the erosion of
diff --git a/api_guides/python/state_ops.md b/api_guides/python/state_ops.md
index 0d612ee..ec2d877 100644
--- a/api_guides/python/state_ops.md
+++ b/api_guides/python/state_ops.md
@@ -83,6 +83,8 @@ automatically by the optimizers in most cases.
 *   @{tf.scatter_sub}
 *   @{tf.scatter_mul}
 *   @{tf.scatter_div}
+*   @{tf.scatter_min}
+*   @{tf.scatter_max}
 *   @{tf.scatter_nd_update}
 *   @{tf.scatter_nd_add}
 *   @{tf.scatter_nd_sub}
diff --git a/community/contributing.md b/community/contributing.md
new file mode 100644
index 0000000..afbb8bb
--- /dev/null
+++ b/community/contributing.md
@@ -0,0 +1,49 @@
+# Contributing to TensorFlow
+
+TensorFlow is an open-source project, and we welcome your participation
+and contribution. This page describes how to get involved.
+
+## Repositories
+
+The code for TensorFlow is hosted in the [TensorFlow GitHub
+organization](https://github.com/tensorflow). Multiple projects are located
+inside the organization, including:
+
+* [TensorFlow](https://github.com/tensorflow/tensorflow)
+* [Models](https://github.com/tensorflow/models)
+* [TensorBoard](https://github.com/tensorflow/tensorboard)
+* [TensorFlow.js](https://github.com/tensorflow/tfjs)
+* [TensorFlow Serving](https://github.com/tensorflow/serving)
+* [TensorFlow Documentation](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/docs_src)
+
+## Contributor checklist
+
+* Before contributing to TensorFlow source code, please review the [contribution
+guidelines](https://github.com/tensorflow/tensorflow/blob/master/CONTRIBUTING.md).
+
+* Join the
+[developers@tensorflow.org](https://groups.google.com/a/tensorflow.org/d/forum/developers)
+mailing list, to coordinate and discuss with others contributing to TensorFlow.
+
+* For coding style conventions, read the @{$style_guide$TensorFlow Style Guide}.
+
+* Finally, review @{$documentation$Writing TensorFlow Documentation}, which
+  explains documentation conventions.
+
+You may also wish to review our guide to @{$benchmarks$defining and running benchmarks}.
+
+## Special Interest Groups
+
+To enable focused collaboration on particular areas of TensorFlow, we host
+Special Interest Groups (SIGs). SIGs do their work in public: if you want to
+join and contribute, review the work of the group, and get in touch with the
+relevant SIG leader.  Membership policies vary on a per-SIG basis.
+
+* **SIG Build** focuses on issues surrounding building, packaging, and
+  distribution of TensorFlow. [Mailing list](https://groups.google.com/a/tensorflow.org/d/forum/build).
+
+* **SIG TensorBoard** furthers the development and direction of TensorBoard and its plugins.
+  [Mailing list](https://groups.google.com/a/tensorflow.org/d/forum/sig-tensorboard).
+
+* **SIG Rust** collaborates on the development of TensorFlow's Rust bindings.
+  [Mailing list](https://groups.google.com/a/tensorflow.org/d/forum/rust).
diff --git a/community/documentation.md b/community/documentation.md
index 003e0a2..d5bc7a5 100644
--- a/community/documentation.md
+++ b/community/documentation.md
@@ -148,19 +148,7 @@ viewing. Do not include url parameters in the source code URL.
 Before building the documentation, you must first set up your environment by
 doing the following:
 
-1. If pip isn't installed on your machine, install it now by issuing the
-following command:
-
-        $ sudo easy_install pip
-
-2. Use pip to install codegen, mock, and pandas by issuing the following
-   command (Note: If you are using
-   a [virtualenv](https://virtualenv.pypa.io/en/stable/) to manage your
-   dependencies, you may not want to use sudo for these installations):
-
-        $ sudo pip install codegen mock pandas
-
-3. If bazel is not installed on your machine, install it now. If you are on
+1. If bazel is not installed on your machine, install it now. If you are on
    Linux, install bazel by issuing the following command:
 
         $ sudo apt-get install bazel  # Linux
@@ -168,10 +156,10 @@ following command:
     If you are on Mac OS, find bazel installation instructions on
     [this page](https://bazel.build/versions/master/docs/install.html#mac-os-x).
 
-4. Change directory to the top-level `tensorflow` directory of the TensorFlow
+2. Change directory to the top-level `tensorflow` directory of the TensorFlow
    source code.
 
-5. Run the `configure` script and answer its prompts appropriately for your
+3. Run the `configure` script and answer its prompts appropriately for your
    system.
 
         $ ./configure
@@ -477,31 +465,29 @@ should use Markdown in the docstring.
 
 Here's a simple example:
 
-```python
-def foo(x, y, name="bar"):
-  """Computes foo.
+    def foo(x, y, name="bar"):
+      """Computes foo.
 
-  Given two 1-D tensors `x` and `y`, this operation computes the foo.
+      Given two 1-D tensors `x` and `y`, this operation computes the foo.
 
-  Example:
+      Example:
 
-  ```
-  # x is [1, 1]
-  # y is [2, 2]
-  tf.foo(x, y) ==> [3, 3]
-  ```
-  Args:
-    x: A `Tensor` of type `int32`.
-    y: A `Tensor` of type `int32`.
-    name: A name for the operation (optional).
+      ```
+      # x is [1, 1]
+      # y is [2, 2]
+      tf.foo(x, y) ==> [3, 3]
+      ```
+      Args:
+        x: A `Tensor` of type `int32`.
+        y: A `Tensor` of type `int32`.
+        name: A name for the operation (optional).
 
-  Returns:
-    A `Tensor` of type `int32` that is the foo of `x` and `y`.
+      Returns:
+        A `Tensor` of type `int32` that is the foo of `x` and `y`.
 
-  Raises:
-    ValueError: If `x` or `y` are not of type `int32`.
-  """
-```
+      Raises:
+        ValueError: If `x` or `y` are not of type `int32`.
+      """
 
 ## Description of the docstring sections
 
diff --git a/community/groups.md b/community/groups.md
new file mode 100644
index 0000000..d92f577
--- /dev/null
+++ b/community/groups.md
@@ -0,0 +1,17 @@
+# User Groups
+
+TensorFlow has communities around the world.
+
+## Asia
+
+* [TensorFlow Korea (TF-KR) User Group](https://www.facebook.com/groups/TensorFlowKR/) _(Korean language)_
+* [TensorFlow User Group Tokyo](https://tfug-tokyo.connpass.com/) _(Japanese Language)_
+* [Soleil Data Dojo](https://soleildatadojo.connpass.com/) _(Japanese language)_
+* [TensorFlow User Group Utsunomiya](https://tfug-utsunomiya.connpass.com/)
+
+
+## Europe
+
+* [TensorFlow Barcelona](https://www.meetup.com/Barcelona-Machine-Learning-Meetup/)
+* [TensorFlow Madrid](https://www.meetup.com/TensorFlow-Madrid/)
+
diff --git a/community/index.md b/community/index.md
index b706d9b..eec2e51 100644
--- a/community/index.md
+++ b/community/index.md
@@ -1,15 +1,85 @@
 # Community
 
-This section contains the following documents:
-
-  * @{$welcome$Welcome to the TensorFlow Community}, which explains how
-    you can get involved, where to report issues, and where to join
-    like-minded TensorFlow enthusiasts online.
-  * @{$roadmap$Roadmap}, which summarizes upcoming additions to TensorFlow.
-  * @{$documentation$Writing TensorFlow Documentation}, which explains
-    TensorFlow's documentation conventions.  If you are modifying
-    TensorFlow source code or documentation, please read this guide.
-  * @{$style_guide$TensorFlow Style Guide}, which identifies coding style
-    conventions that TensorFlow developers and users should follow.
-  * @{$community/benchmarks$Benchmarks}, Benchmarks, a guide for defining and
-    running a TensorFlow benchmark.
+Welcome to the TensorFlow community! This page explains where to get help, and
+different ways to be part of the community. We are committed to fostering an
+open and welcoming environment, and request that you review our [code of
+conduct](https://github.com/tensorflow/tensorflow/blob/master/CODE_OF_CONDUCT.md).
+
+## Get Help
+
+### Technical Questions
+
+To ask or answer technical questions about TensorFlow, use [Stack
+Overflow](https://stackoverflow.com/questions/tagged/tensorflow). For example,
+ask or search about a particular error message you encountered during
+installation.
+
+### Bugs and Feature Requests
+
+To report bugs or make feature requests, file an issue on GitHub. Please choose
+the appropriate repository for the project. Major repositories include:
+
+  * [TensorFlow](https://github.com/tensorflow/tensorflow/issues)
+  * [TensorBoard](https://github.com/tensorflow/tensorboard/issues)
+  * [TensorFlow models](https://github.com/tensorflow/models/issues)
+  
+### Security
+
+Before using TensorFlow, please take a look at our security model, list of
+recent security announcements, and ways you can report security issues to the
+TensorFlow team at the
+[Using TensorFlow Securely](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) page on GitHub.
+
+## Stay Informed
+
+### Announcements Mailing List
+
+All major releases and important announcements are sent to
+[announce@tensorflow.org](https://groups.google.com/a/tensorflow.org/forum/#!forum/announce).
+We recommend that you join this list if you depend on TensorFlow in any way.
+
+### Development Roadmap
+
+The @{$roadmap$Roadmap} summarizes plans for upcoming additions to TensorFlow.
+
+### Social Media
+
+For news and updates from around the universe of TensorFlow projects, follow
+[@tensorflow](https://twitter.com/tensorflow) on Twitter.
+
+### Blog
+
+We post regularly to the [TensorFlow Blog](http://blog.tensorflow.org/),
+with content from the TensorFlow team and the best articles from the community.
+
+### YouTube
+
+Our [YouTube Channel](http://youtube.com/tensorflow/) focuses on machine learing
+and AI with TensorFlow. On it we have a number of new shows, including:
+
+- TensorFlow Meets: meet with community contributors to learn and share what they're doing
+- Ask TensorFlow: the team answers the best questions tagged #AskTensorFlow from social media 
+- Coding TensorFlow: short bites with tips for success with TensorFlow
+
+## Community Support
+
+### Mailing Lists
+
+For general discussion about TensorFlow development and direction, please join
+the [TensorFlow discuss mailing
+list](https://groups.google.com/a/tensorflow.org/d/forum/discuss).
+
+A number of other mailing lists exist, focused on different project areas, which
+can be found at @{$lists$TensorFlow Mailing Lists}.
+
+### User Groups
+
+To meet with like-minded people local to you, check out the many
+@{$groups$TensorFlow user groups} around the world.
+
+
+## Contributing To TensorFlow
+
+We welcome contributions and collaboration on TensorFlow. For more information,
+please read [Contributing to TensorFlow](contributing.md).
+
diff --git a/community/leftnav_files b/community/leftnav_files
index fab3502..2bae60d 100644
--- a/community/leftnav_files
+++ b/community/leftnav_files
@@ -1,6 +1,9 @@
 index.md
-welcome.md
 roadmap.md
+contributing.md
+lists.md
+groups.md
 documentation.md
 style_guide.md
 benchmarks.md
+swift.md
diff --git a/community/lists.md b/community/lists.md
new file mode 100644
index 0000000..7450ab3
--- /dev/null
+++ b/community/lists.md
@@ -0,0 +1,51 @@
+# Mailing Lists
+
+As a community, we do much of our collaboration on public mailing lists.
+Please note that if you're looking for help using TensorFlow, [Stack
+Overflow](https://stackoverflow.com/questions/tagged/tensorflow) and
+[GitHub issues](https://github.com/tensorflow/tensorflow/issues)
+are the best initial places to look. For more information,
+see [how to get help](/community/#get_help).
+
+## General TensorFlow lists
+
+* [announce](https://groups.google.com/a/tensorflow.org/d/forum/announce) - Low-volume announcements of new releases.
+* [discuss](https://groups.google.com/a/tensorflow.org/d/forum/discuss) - General community discussion around TensorFlow.
+* [developers](https://groups.google.com/a/tensorflow.org/d/forum/developers) - Discussion for developers contributing to TensorFlow.
+
+## Project-specific lists
+
+These projects inside the TensorFlow GitHub organization have lists dedicated to their communities:
+
+* [hub](https://groups.google.com/a/tensorflow.org/d/forum/hub) -
+  Discussion and collaboration around [TensorFlow Hub](https://github.com/tensorflow/hub).
+* [magenta-discuss](https://groups.google.com/a/tensorflow.org/d/forum/magenta-discuss) -
+  General discussion about [Magenta](https://magenta.tensorflow.org/)
+  development and directions.
+* [swift](https://groups.google.com/a/tensorflow.org/d/forum/swift) -
+  Community and collaboration around Swift for TensorFlow.
+* [tensor2tensor](https://groups.google.com/d/forum/tensor2tensor) - Discussion
+  and peer support for Tensor2Tensor.
+* [tfjs-announce](https://groups.google.com/a/tensorflow.org/d/forum/tfjs-announce) -
+  Announcements of new TensorFlow.js releases.
+* [tfjs](https://groups.google.com/a/tensorflow.org/d/forum/tfjs) - Discussion
+  and peer support for TensorFlow.js.
+* [tflite](https://groups.google.com/a/tensorflow.org/d/forum/tflite) - Discussion and
+  peer support for TensorFlow Lite.
+* [tpu-users](https://groups.google.com/a/tensorflow.org/d/forum/tpu-users) - Community discussion
+  and support for TPU users.
+
+## Special Interest Groups
+
+TensorFlow's [Special Interest
+Groups](/community/contributing#special_interest_groups) (SIGs) support
+community collaboration on particular project focuses. Members of these groups
+work together to build and support TensorFlow related projects. While their
+archives are public, different SIGs have their own membership policies.
+
+* [build](https://groups.google.com/a/tensorflow.org/d/forum/build) -
+  Supporting SIG Build, for build, distribution and packaging of TensorFlow.
+* [sig-tensorboard](https://groups.google.com/a/tensorflow.org/d/forum/sig-tensorboard) -
+  Supporting SIG TensorBoard, for plugin development and other contribution.
+* [rust](https://groups.google.com/a/tensorflow.org/d/forum/rust) -
+  Supporting SIG Rust, for the Rust language bindings.
diff --git a/community/security.md b/community/security.md
new file mode 100644
index 0000000..8d13c7a
--- /dev/null
+++ b/community/security.md
@@ -0,0 +1,7 @@
+# Using TensorFlow Securely
+
+Before using TensorFlow, please take a look at our security model, list of
+recent security announcements, and ways you can report security issues to the
+TensorFlow team at the
+[https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md](Using
+TensorFlow Securely) page on GitHub.
diff --git a/community/swift.md b/community/swift.md
new file mode 100644
index 0000000..54d9960
--- /dev/null
+++ b/community/swift.md
@@ -0,0 +1,35 @@
+# Swift Community
+
+Welcome to the Swift for TensorFlow development community!
+
+Swift for TensorFlow is a result of first-principles thinking applied to machine
+learning frameworks, and works quite differently than existing TensorFlow
+language bindings.  Whereas prior solutions are designed within the constraints
+of what can be achieved by a (typically Python or Lua) library, Swift for
+TensorFlow is based on the belief that machine learning is important enough to
+deserve first-class language and compiler support.
+
+First-class language and compiler support allows us to innovate in areas that
+have traditionally been out of bounds for machine learning libraries.  Our
+results provide the performance of TensorFlow graphs with the ease of use of
+define-by-run models, and provides a great user experience - for example, by
+catching more mistakes before you run your code.
+
+## Open Source
+
+As announced at the TensorFlow Developer Summit, we are planning to launch our
+open source project on GitHub in April.  In addition to releasing the code, we
+will be using an open design model, where design discussions happen in public.
+
+Between now and then, we are writing some technical white papers that explain in
+detail the design approach (e.g., the core compiler partitioning technique that
+underlies the whole thing, our approach to automatic differentiation, etc.),
+implementation tradeoffs, and the status of this work.  We can’t wait to engage
+with the broader community, but prefer to start the conversation when these
+white papers are ready.
+
+[Sign up here to join the community Google
+group](https://groups.google.com/a/tensorflow.org/d/forum/swift). We will
+initially use it for announcements, and then open it for general discussion when
+we are ready in April.
+
diff --git a/community/welcome.md b/community/welcome.md
deleted file mode 100644
index 9f6fe91..0000000
--- a/community/welcome.md
+++ /dev/null
@@ -1,69 +0,0 @@
-# Welcome to the TensorFlow Community
-
-TensorFlow is an open-source project.  This page explains how to contribute,
-where to ask questions, and how to help each other.
-
-
-## Development
-
-The source code for TensorFlow is on
-[GitHub](https://github.com/tensorflow/tensorflow).
-
-Before contributing to TensorFlow source code, please review the
-[Contribution guidelines](https://github.com/tensorflow/tensorflow/blob/master/CONTRIBUTING.md).
-
-### Projects developed by the TensorFlow community
-
-The TensorFlow community has created many great projects around TensorFlow, including:
-
-* [Machine Learning with TensorFlow (Book & Code)](http://tensorflowbook.com)
-* [@jtoy's awesome "Awesome TensorFlow" list of awesome things](https://github.com/jtoy/awesome-tensorflow)
-* [TensorFlow tutorials](https://github.com/pkmital/tensorflow_tutorials)
-* [Caffe to TensorFlow model converter](https://github.com/ethereon/caffe-tensorflow)
-* [Bitfusion's` GPU-enabled AWS EC2 TensorFlow AMI](https://github.com/bitfusionio/amis/tree/master/awsmrkt-bfboost-ubuntu14-cuda75-tensorflow) ([Launch AMI](https://aws.amazon.com/marketplace/pp/B01EYKBEQ0))
-* [Rust language bindings](https://github.com/google/tensorflow-rust)
-* [Operator Vectorization Library](https://github.com/opveclib/opveclib)
-* [Swift language bindings](https://github.com/PerfectlySoft/Perfect-TensorFlow)
-* [Sublime Tensorflow - A plugin for Sublime Text](https://github.com/baptisteArnaud/Sublime-Tensorflow)
-* [Edward - A library for probabilistic modeling, inference, and criticism](http://edwardlib.org) ([Github](https://github.com/blei-lab/edward), [Forum](https://discourse.edwardlib.org))
-* [GPflow - Gaussian processes in TensorFlow](https://github.com/GPflow/GPflow)
-* [CS 20SI: Tensorflow for Deep Learning Research](https://web.stanford.edu/class/cs20si/) - Please note, this course was designed with TensorFlow v0.12, so some of the notes may be out of date - but it's still a great resource.
-
-## TensorFlow Communities Around the World
-
-Asia:
-
-* [TensorFlow Korea (TF-KR) User Group](https://www.facebook.com/groups/TensorFlowKR/) _(Korean language)_
-* [TensorFlow User Group Tokyo](https://tfug-tokyo.connpass.com/) _(Japanese Language)_
-* [Soleil Data Dojo](https://soleildatadojo.connpass.com/) _(Japanese language)_
-* [TensorFlow User Group Utsunomiya](https://tfug-utsunomiya.connpass.com/)
-
-
-Europe:
-
-* [TensorFlow Barcelona](https://www.meetup.com/Barcelona-Machine-Learning-Meetup/)
-* [TensorFlow Madrid](https://www.meetup.com/TensorFlow-Madrid/)
-
-
-
-## Support
-
-TensorFlow provides multiple communication paths.  To pick the right path,
-please read the following list carefully:
-
-  * To ask or answer technical questions about TensorFlow, use
-    [Stack Overflow](https://stackoverflow.com/questions/tagged/tensorflow).
-    For example, ask or search Stack Overflow about a particular error message
-    you encountered during installation.
-  * To join general discussions about TensorFlow development and directions,
-    please join the
-    [TensorFlow discuss mailing list](https://groups.google.com/a/tensorflow.org/d/forum/discuss).
-    For example, use this mailing list to learn about new features in
-    upcoming releases of TensorFlow.
-  * To report bugs or make feature requests, use the
-    [TensorFlow issues tracker](https://github.com/tensorflow/tensorflow/issues)
-    on GitHub.  For example, use the issue tracker to request a
-    new operation in TensorFlow.
-  * To report vulnerabilities, please follow our
-    [vulnerability disclosure guidelines](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/SECURITY.md).
-

From c5664bbfd22babc98ac78266b8395b646334849f Mon Sep 17 00:00:00 2001
From: Ding Xue-wen <xuewending1995@gmail.com>
Date: Fri, 20 Apr 2018 14:55:44 +0800
Subject: [PATCH 4/7] update to v1.8

---
 README.md                                     |   9 +-
 deploy/deploy_to_js.md                        |   4 +
 deploy/leftnav_files                          |   1 +
 extend/add_filesys.md                         |   2 +-
 extend/index.md                               |   5 +-
 extend/new_data_formats.md                    | 395 ++++----
 get_started/custom_estimators.md              |   2 +-
 get_started/eager.md                          |   3 +
 get_started/get_started_for_beginners.md      |  36 +-
 get_started/index.md                          |  18 +-
 get_started/leftnav_files                     |   8 +-
 get_started/premade_estimators.md             |   7 +-
 install/install_c.md                          |   4 +-
 install/install_go.md                         |   2 +-
 install/install_java.md                       |  22 +-
 install/install_linux.md                      |  70 +-
 install/install_mac.md                        |  31 +-
 install/install_sources.md                    |  64 +-
 install/install_windows.md                    |  14 +-
 javascript/index.md                           |   5 +
 javascript/leftnav_files                      |   1 +
 mobile/leftnav_files                          |   1 +
 mobile/optimizing.md                          |   2 +
 mobile/prepare_models.md                      |   2 +-
 mobile/tflite/demo_android.md                 | 156 +++-
 mobile/tflite/demo_ios.md                     |   2 +-
 mobile/tflite/devguide.md                     | 231 +++++
 mobile/tflite/index.md                        |   4 +-
 performance/leftnav_files                     |   1 +
 performance/performance_guide.md              |   2 +-
 performance/xla/jit.md                        |   2 +-
 performance/xla/operation_semantics.md        |  15 +-
 programmers_guide/debugger.md                 |  78 +-
 programmers_guide/eager.md                    | 848 ++++++++++++++++++
 programmers_guide/embedding.md                |   3 +
 programmers_guide/faq.md                      |   4 +-
 programmers_guide/index.md                    |   1 +
 programmers_guide/leftnav_files               |   3 +-
 programmers_guide/saved_model.md              |  48 +-
 .../summaries_and_tensorboard.md              |   2 +-
 programmers_guide/using_tpu.md                |  17 +-
 programmers_guide/version_compat.md           |  47 +-
 tutorials/deep_cnn.md                         |   2 +-
 tutorials/image_retraining.md                 |   2 +-
 tutorials/kernel_methods.md                   |   8 +-
 tutorials/layers.md                           |  64 +-
 tutorials/recurrent_quickdraw.md              |  11 +-
 tutorials/wide.md                             |   4 +-
 48 files changed, 1831 insertions(+), 432 deletions(-)
 create mode 100644 deploy/deploy_to_js.md
 create mode 100644 get_started/eager.md
 create mode 100644 javascript/index.md
 create mode 100644 javascript/leftnav_files
 create mode 100644 mobile/tflite/devguide.md
 create mode 100644 programmers_guide/eager.md

diff --git a/README.md b/README.md
index ef5bdc6..99f4a25 100644
--- a/README.md
+++ b/README.md
@@ -7,12 +7,12 @@
 
 | **`Documentation`** | **`Linux CPU`** | **`Linux GPU`** | **`Mac OS CPU`** | **`Windows CPU`** | **`Android`** |
 |-----------------|---------------------|------------------|-------------------|---------------|---------------|
-| [![Documentation](https://img.shields.io/badge/api-reference-blue.svg)](https://www.tensorflow.org/api_docs/) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-cpu)](https://ci.tensorflow.org/job/tensorflow-master-cpu) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-linux-gpu)](https://ci.tensorflow.org/job/tensorflow-master-linux-gpu) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-mac)](https://ci.tensorflow.org/job/tensorflow-master-mac) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-win-cmake-py)](https://ci.tensorflow.org/job/tensorflow-master-win-cmake-py) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-android)](https://ci.tensorflow.org/job/tensorflow-master-android) [ ![Download](https://api.bintray.com/packages/google/tensorflow/tensorflow/images/download.svg) ](https://bintray.com/google/tensorflow/tensorflow/_latestVersion)
+| [![Documentation](https://img.shields.io/badge/api-reference-blue.svg)](https://www.tensorflow.org/api_docs/) | ![Build Status](https://storage.cloud.google.com/tensorflow-kokoro-build-badges/ubuntu-cc.png) | ![Build Status](https://storage.cloud.google.com/tensorflow-kokoro-build-badges/ubuntu-gpu-cc.png) | ![Build Status](https://storage.cloud.google.com/tensorflow-kokoro-build-badges/macos-py2-cc.png) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-win-cmake-py)](https://ci.tensorflow.org/job/tensorflow-master-win-cmake-py) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-android)](https://ci.tensorflow.org/job/tensorflow-master-android) [ ![Download](https://api.bintray.com/packages/google/tensorflow/tensorflow/images/download.svg) ](https://bintray.com/google/tensorflow/tensorflow/_latestVersion)
 
 **TensorFlow** is an open source software library for numerical computation using
 data flow graphs.  The graph nodes represent mathematical operations, while
 the graph edges represent the multidimensional data arrays (tensors) that flow
-between them.  This flexible architecture lets you deploy computation to one
+between them.  This flexible architecture enables you to deploy computation to one
 or more CPUs or GPUs in a desktop, server, or mobile device without rewriting
 code.  TensorFlow also includes TensorBoard, a data visualization toolkit.
 
@@ -22,6 +22,10 @@ organization for the purposes of conducting machine learning and deep neural
 networks research.  The system is general enough to be applicable in a wide
 variety of other domains, as well.
 
+Keep up to date with release announcements and security updates by
+subscribing to
+[announce@tensorflow.org](https://groups.google.com/a/tensorflow.org/forum/#!forum/announce).
+
 ## Installation
 *See [Installing TensorFlow](https://www.tensorflow.org/get_started/os_setup.html) for instructions on how to install our release binaries or how to build from source.*
 
@@ -82,6 +86,7 @@ The TensorFlow project strives to abide by generally accepted best practices in
 
 * [TensorFlow Website](https://www.tensorflow.org)
 * [TensorFlow White Papers](https://www.tensorflow.org/about/bib)
+* [TensorFlow YouTube Channel](https://www.youtube.com/channel/UC0rqucBdTuFTjJiefW5t-IQ)
 * [TensorFlow Model Zoo](https://github.com/tensorflow/models)
 * [TensorFlow MOOC on Udacity](https://www.udacity.com/course/deep-learning--ud730)
 * [TensorFlow Course at Stanford](https://web.stanford.edu/class/cs20si)
diff --git a/deploy/deploy_to_js.md b/deploy/deploy_to_js.md
new file mode 100644
index 0000000..d7ce3ea
--- /dev/null
+++ b/deploy/deploy_to_js.md
@@ -0,0 +1,4 @@
+# Deploy to JavaScript
+
+You can find details about deploying JavaScript TensorFlow programs
+in the separate [js.tensorflow.org site](https://js.tensorflow.org).
diff --git a/deploy/leftnav_files b/deploy/leftnav_files
index c682e7a..93f5bd1 100644
--- a/deploy/leftnav_files
+++ b/deploy/leftnav_files
@@ -2,3 +2,4 @@ index.md
 distributed.md
 hadoop.md
 s3.md
+deploy_to_js.md
diff --git a/extend/add_filesys.md b/extend/add_filesys.md
index 06f11de..bc0f662 100644
--- a/extend/add_filesys.md
+++ b/extend/add_filesys.md
@@ -225,7 +225,7 @@ it will use the `FooBarFileSystem` implementation.
 Next, you must build a shared object containing this implementation. An example
 of doing so using bazel's `cc_binary` rule can be found
 [here](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/BUILD#L244),
-but you may use any build system to do so. See the section on @{$adding_an_op#build-the-op-library$building the op library} for similar
+but you may use any build system to do so. See the section on @{$adding_an_op#build_the_op_library$building the op library} for similar
 instructions.
 
 The result of building this target is a `.so` shared object file.
diff --git a/extend/index.md b/extend/index.md
index bdff60b..1ab0340 100644
--- a/extend/index.md
+++ b/extend/index.md
@@ -16,9 +16,10 @@ TensorFlow:
     for your own file and record formats.
 
 Python is currently the only language supported by TensorFlow's API stability
-promises.  However, TensorFlow also provides functionality in C++, Java, and Go,
+promises. However, TensorFlow also provides functionality in C++, Go, Java and
+[JavaScript](https://js.tensorflow.org),
 plus community support for [Haskell](https://github.com/tensorflow/haskell) and
-[Rust](https://github.com/tensorflow/rust).  If you'd like to create or
+[Rust](https://github.com/tensorflow/rust). If you'd like to create or
 develop TensorFlow features in a language other than these languages, read the
 following guide:
 
diff --git a/extend/new_data_formats.md b/extend/new_data_formats.md
index b3cc968..2c33a6b 100644
--- a/extend/new_data_formats.md
+++ b/extend/new_data_formats.md
@@ -1,4 +1,4 @@
-# Custom Data Readers
+# Reading custom file and record formats
 
 PREREQUISITES:
 
@@ -9,187 +9,273 @@ PREREQUISITES:
 
 We divide the task of supporting a file format into two pieces:
 
-*   File formats: We use a *Reader* Op to read a *record* (which can be any
-    string) from a file.
-*   Record formats: We use decoder or parsing Ops to turn a string record
+*   File formats: We use a reader `tf.data.Dataset` to read raw *records* (which
+    are typically represented by scalar string tensors, but can have more
+    structure) from a file.
+*   Record formats: We use decoder or parsing ops to turn a string record
     into tensors usable by TensorFlow.
 
 For example, to read a
 [CSV file](https://en.wikipedia.org/wiki/Comma-separated_values), we use
-@{tf.TextLineReader$a Reader for text files}
-followed by
-@{tf.decode_csv$an Op that parses CSV data from a line of text}.
+@{tf.data.TextLineDataset$a dataset for reading text files line-by-line}
+and then @{tf.data.Dataset.map$map} an
+@{tf.decode_csv$op} that parses CSV data from each line of text in the dataset.
 
 [TOC]
 
-## Writing a Reader for a file format
+## Writing a `Dataset` for a file format
 
-A `Reader` is something that reads records from a file.  There are some examples
-of Reader Ops already built into TensorFlow:
+A @{tf.data.Dataset} represents a sequence of *elements*, which can be the
+individual records in a file. There are several examples of "reader" datasets
+that are already built into TensorFlow:
 
-*   @{tf.TFRecordReader}
-    ([source in `kernels/tf_record_reader_op.cc`](https://www.tensorflow.org/code/tensorflow/core/kernels/tf_record_reader_op.cc))
-*   @{tf.FixedLengthRecordReader}
-    ([source in `kernels/fixed_length_record_reader_op.cc`](https://www.tensorflow.org/code/tensorflow/core/kernels/fixed_length_record_reader_op.cc))
-*   @{tf.TextLineReader}
-    ([source in `kernels/text_line_reader_op.cc`](https://www.tensorflow.org/code/tensorflow/core/kernels/text_line_reader_op.cc))
+*   @{tf.data.TFRecordDataset}
+    ([source in `kernels/data/reader_dataset_ops.cc`](https://www.tensorflow.org/code/tensorflow/core/kernels/data/reader_dataset_ops.cc))
+*   @{tf.data.FixedLengthRecordDataset}
+    ([source in `kernels/data/reader_dataset_ops.cc`](https://www.tensorflow.org/code/tensorflow/core/kernels/data/reader_dataset_ops.cc))
+*   @{tf.data.TextLineDataset}
+    ([source in `kernels/data/reader_dataset_ops.cc`](https://www.tensorflow.org/code/tensorflow/core/kernels/data/reader_dataset_ops.cc))
 
-You can see these all expose the same interface, the only differences
-are in their constructors.  The most important method is `read`.
-It takes a queue argument, which is where it gets filenames to
-read from whenever it needs one (e.g. when the `read` op first runs, or
-the previous `read` reads the last record from a file).  It produces
-two scalar tensors: a string key and a string value.
+Each of these implementations comprises three related classes:
 
-To create a new reader called `SomeReader`, you will need to:
+* A `tensorflow::DatasetOpKernel` subclass (e.g. `TextLineDatasetOp`), which
+  tells TensorFlow how to construct a dataset object from the inputs to and
+  attrs of an op, in its `MakeDataset()` method.
 
-1.  In C++, define a subclass of
-    [`tensorflow::ReaderBase`](https://www.tensorflow.org/code/tensorflow/core/framework/reader_base.h)
-    called `SomeReader`.
-2.  In C++, register a new reader op and kernel with the name `"SomeReader"`.
-3.  In Python, define a subclass of @{tf.ReaderBase} called `SomeReader`.
+* A `tensorflow::GraphDatasetBase` subclass (e.g. `TextLineDatasetOp::Dataset`),
+  which represents the *immutable* definition of the dataset itself, and tells
+  TensorFlow how to construct an iterator object over that dataset, in its
+  `MakeIterator()` method.
 
-You can put all the C++ code in a file in
-`tensorflow/core/user_ops/some_reader_op.cc`. The code to read a file will live
-in a descendant of the C++ `ReaderBase` class, which is defined in
-[`tensorflow/core/kernels/reader_base.h`](https://www.tensorflow.org/code/tensorflow/core/framework/reader_base.h).
-You will need to implement the following methods:
+* A `tensorflow::DatasetIterator<Dataset>` subclass (e.g.
+  `TextLineDatasetOp::Dataset::Iterator`), which represents the *mutable* state
+  of an iterator over a particular dataset, and tells TensorFlow how to get the
+  next element from the iterator, in its `GetNextInternal()` method.
 
-*   `OnWorkStartedLocked`: open the next file
-*   `ReadLocked`: read a record or report EOF/error
-*   `OnWorkFinishedLocked`: close the current file, and
-*   `ResetLocked`: get a clean slate after, e.g., an error
+The most important method is the `GetNextInternal()` method, since it defines
+how to actually read records from the file and represent them as one or more
+`Tensor` objects.
 
-These methods have names ending in "Locked" since `ReaderBase` makes sure
-to acquire a mutex before calling any of these methods, so you generally don't
-have to worry about thread safety (though that only protects the members of the
-class, not global state).
+To create a new reader dataset called (for example) `MyReaderDataset`, you will
+need to:
 
-For `OnWorkStartedLocked`, the name of the file to open is the value returned by
-the `current_work()` method.  `ReadLocked` has this signature:
+1. In C++, define subclasses of `tensorflow::DatasetOpKernel`,
+   `tensorflow::GraphDatasetBase`, and `tensorflow::DatasetIterator<Dataset>`
+   that implement the reading logic.
+2. In C++, register a new reader op and kernel with the name
+   `"MyReaderDataset"`.
+3. In Python, define a subclass of @{tf.data.Dataset} called `MyReaderDataset`.
 
-```c++
-Status ReadLocked(string* key, string* value, bool* produced, bool* at_end)
-```
-
-If `ReadLocked` successfully reads a record from the file, it should fill in:
-
-*   `*key`: with an identifier for the record, that a human could use to find
-    this record again.  You can include the filename from `current_work()`,
-    and append a record number or whatever.
-*   `*value`: with the contents of the record.
-*   `*produced`: set to `true`.
-
-If you hit the end of a file (EOF), set `*at_end` to `true`.  In either case,
-return `Status::OK()`.  If there is an error, simply return it using one of the
-helper functions from
-[`tensorflow/core/lib/core/errors.h`](https://www.tensorflow.org/code/tensorflow/core/lib/core/errors.h)
-without modifying any arguments.
-
-Next you will create the actual Reader op.  It will help if you are familiar
-with @{$adding_an_op$the adding an op how-to}.  The main steps
-are:
-
-*   Registering the op.
-*   Define and register an `OpKernel`.
-
-To register the op, you will use a `REGISTER_OP` call defined in
-[`tensorflow/core/framework/op.h`](https://www.tensorflow.org/code/tensorflow/core/framework/op.h).
-Reader ops never take any input and always have a single output with type
-`resource`.  They should have string `container` and `shared_name` attrs.
-You may optionally define additional attrs
-for configuration or include documentation in a `Doc`.  For examples, see
-[`tensorflow/core/ops/io_ops.cc`](https://www.tensorflow.org/code/tensorflow/core/ops/io_ops.cc),
-e.g.:
+You can put all the C++ code in a single file, such as
+`my_reader_dataset_op.cc`. It will help if you are
+familiar with @{$adding_an_op$the adding an op how-to}. The following skeleton
+can be used as a starting point for your implementation:
 
 ```c++
+#include "tensorflow/core/framework/common_shape_fns.h"
+#include "tensorflow/core/framework/dataset.h"
 #include "tensorflow/core/framework/op.h"
+#include "tensorflow/core/framework/shape_inference.h"
 
-REGISTER_OP("TextLineReader")
-    .Output("reader_handle: resource")
-    .Attr("skip_header_lines: int = 0")
-    .Attr("container: string = ''")
-    .Attr("shared_name: string = ''")
-    .SetIsStateful()
-    .SetShapeFn(shape_inference::ScalarShape)
-    .Doc(R"doc(
-A Reader that outputs the lines of a file delimited by '\n'.
-)doc");
-```
-
-To define an `OpKernel`, Readers can use the shortcut of descending from
-`ReaderOpKernel`, defined in
-[`tensorflow/core/framework/reader_op_kernel.h`](https://www.tensorflow.org/code/tensorflow/core/framework/reader_op_kernel.h),
-and implement a constructor that calls `SetReaderFactory`.  After defining
-your class, you will need to register it using `REGISTER_KERNEL_BUILDER(...)`.
-An example with no attrs:
+namespace tensorflow {
+namespace {
 
-```c++
-#include "tensorflow/core/framework/reader_op_kernel.h"
-
-class TFRecordReaderOp : public ReaderOpKernel {
+class MyReaderDatasetOp : public DatasetOpKernel {
  public:
-  explicit TFRecordReaderOp(OpKernelConstruction* context)
-      : ReaderOpKernel(context) {
-    Env* env = context->env();
-    SetReaderFactory([this, env]() { return new TFRecordReader(name(), env); });
-  }
-};
 
-REGISTER_KERNEL_BUILDER(Name("TFRecordReader").Device(DEVICE_CPU),
-                        TFRecordReaderOp);
-```
+  MyReaderDatasetOp(OpKernelConstruction* ctx) : DatasetOpKernel(ctx) {
+    // Parse and validate any attrs that define the dataset using
+    // `ctx->GetAttr()`, and store them in member variables.
+  }
 
-An example with attrs:
+  void MakeDataset(OpKernelContext* ctx, DatasetBase** output) override {
+    // Parse and validate any input tensors 0that define the dataset using
+    // `ctx->input()` or the utility function
+    // `ParseScalarArgument<T>(ctx, &arg)`.
 
-```c++
-#include "tensorflow/core/framework/reader_op_kernel.h"
-
-class TextLineReaderOp : public ReaderOpKernel {
- public:
-  explicit TextLineReaderOp(OpKernelConstruction* context)
-      : ReaderOpKernel(context) {
-    int skip_header_lines = -1;
-    OP_REQUIRES_OK(context,
-                   context->GetAttr("skip_header_lines", &skip_header_lines));
-    OP_REQUIRES(context, skip_header_lines >= 0,
-                errors::InvalidArgument("skip_header_lines must be >= 0 not ",
-                                        skip_header_lines));
-    Env* env = context->env();
-    SetReaderFactory([this, skip_header_lines, env]() {
-      return new TextLineReader(name(), skip_header_lines, env);
-    });
+    // Create the dataset object, passing any (already-validated) arguments from
+    // attrs or input tensors.
+    *output = new Dataset(ctx);
   }
-};
 
-REGISTER_KERNEL_BUILDER(Name("TextLineReader").Device(DEVICE_CPU),
-                        TextLineReaderOp);
-```
-
-The last step is to add the Python wrapper.  You can either do this by
-@{$adding_an_op#building_the_op_library$compiling a dynamic library}
-or, if you are building TensorFlow from source, adding to `user_ops.py`.
-For the latter, you will import `tensorflow.python.ops.io_ops` in
-[`tensorflow/python/user_ops/user_ops.py`](https://www.tensorflow.org/code/tensorflow/python/user_ops/user_ops.py)
-and add a descendant of [`io_ops.ReaderBase`](https://www.tensorflow.org/code/tensorflow/python/ops/io_ops.py).
+ private:
+  class Dataset : public GraphDatasetBase {
+   public:
+    Dataset(OpKernelContext* ctx) : GraphDatasetBase(ctx) {}
+
+    std::unique_ptr<IteratorBase> MakeIterator(
+        const string& prefix) const override {
+      return std::unique_ptr<IteratorBase>(
+          new Iterator({this, strings::StrCat(prefix, "::MyReader")}));
+    }
+
+    // Record structure: Each record is represented by a scalar string tensor.
+    //
+    // Dataset elements can have a fixed number of components of different
+    // types and shapes; replace the following two methods to customize this
+    // aspect of the dataset.
+    const DataTypeVector& output_dtypes() const override {
+      static DataTypeVector* dtypes = new DataTypeVector({DT_STRING});
+      return *dtypes;
+    }
+    const std::vector<PartialTensorShape>& output_shapes() const override {
+      static std::vector<PartialTensorShape>* shapes =
+          new std::vector<PartialTensorShape>({{}});
+      return *shapes;
+    }
+
+    string DebugString() override { return "MyReaderDatasetOp::Dataset"; }
+
+   protected:
+    // Optional: Implementation of `GraphDef` serialization for this dataset.
+    //
+    // Implement this method if you want to be able to save and restore
+    // instances of this dataset (and any iterators over it).
+    Status AsGraphDefInternal(DatasetGraphDefBuilder* b,
+                              Node** output) const override {
+      // Construct nodes to represent any of the input tensors from this
+      // object's member variables using `b->AddScalar()` and `b->AddVector()`.
+      std::vector<Node*> input_tensors;
+      TF_RETURN_IF_ERROR(b->AddDataset(this, input_tensors, output));
+      return Status::OK();
+    }
+
+   private:
+    class Iterator : public DatasetIterator<Dataset> {
+     public:
+      explicit Iterator(const Params& params)
+          : DatasetIterator<Dataset>(params), i_(0) {}
+
+      // Implementation of the reading logic.
+      //
+      // The example implementation in this file yields the string "MyReader!"
+      // ten times. In general there are three cases:
+      //
+      // 1. If an element is successfully read, store it as one or more tensors
+      //    in `*out_tensors`, set `*end_of_sequence = false` and return
+      //    `Status::OK()`.
+      // 2. If the end of input is reached, set `*end_of_sequence = true` and
+      //    return `Status::OK()`.
+      // 3. If an error occurs, return an error status using one of the helper
+      //    functions from "tensorflow/core/lib/core/errors.h".
+      Status GetNextInternal(IteratorContext* ctx,
+                             std::vector<Tensor>* out_tensors,
+                             bool* end_of_sequence) override {
+        // NOTE: `GetNextInternal()` may be called concurrently, so it is
+        // recommended that you protect the iterator state with a mutex.
+        mutex_lock l(mu_);
+        if (i_ < 10) {
+          // Create a scalar string tensor and add it to the output.
+          Tensor record_tensor(ctx->allocator({}), DT_STRING, {});
+          record_tensor.scalar<string>()() = "MyReader!";
+          out_tensors->emplace_back(std::move(record_tensor));
+          ++i_;
+          *end_of_sequence = false;
+        } else {
+          *end_of_sequence = true;
+        }
+        return Status::OK();
+      }
+
+     protected:
+      // Optional: Implementation of iterator state serialization for this
+      // iterator.
+      //
+      // Implement these two methods if you want to be able to save and restore
+      // instances of this iterator.
+      Status SaveInternal(IteratorStateWriter* writer) override {
+        mutex_lock l(mu_);
+        TF_RETURN_IF_ERROR(writer->WriteScalar(full_name("i"), i_));
+        return Status::OK();
+      }
+      Status RestoreInternal(IteratorContext* ctx,
+                             IteratorStateReader* reader) override {
+        mutex_lock l(mu_);
+        TF_RETURN_IF_ERROR(reader->ReadScalar(full_name("i"), &i_));
+        return Status::OK();
+      }
+
+     private:
+      mutex mu_;
+      int64 i_ GUARDED_BY(mu_);
+    };
+  };
+};
 
-```python
-from tensorflow.python.framework import ops
-from tensorflow.python.ops import common_shapes
-from tensorflow.python.ops import io_ops
+// Register the op definition for MyReaderDataset.
+//
+// Dataset ops always have a single output, of type `variant`, which represents
+// the constructed `Dataset` object.
+//
+// Add any attrs and input tensors that define the dataset here.
+REGISTER_OP("MyReaderDataset")
+    .Output("handle: variant")
+    .SetIsStateful()
+    .SetShapeFn(shape_inference::ScalarShape);
 
-class SomeReader(io_ops.ReaderBase):
+// Register the kernel implementation for MyReaderDataset.
+REGISTER_KERNEL_BUILDER(Name("MyReaderDataset").Device(DEVICE_CPU),
+                        MyReaderDatasetOp);
 
-    def __init__(self, name=None):
-        rr = gen_user_ops.some_reader(name=name)
-        super(SomeReader, self).__init__(rr)
+}  // namespace
+}  // namespace tensorflow
+```
 
+The last step is to build the C++ code and add a Python wrapper. The easiest way
+to do this is by @{$adding_an_op#build_the_op_library$compiling a dynamic
+library} (e.g. called `"my_reader_dataset_op.so"`), and adding a Python class
+that subclasses @{tf.data.Dataset} to wrap it. An example Python program is
+given here:
 
-ops.NotDifferentiable("SomeReader")
+```python
+import tensorflow as tf
+
+# Assumes the file is in the current working directory.
+my_reader_dataset_module = tf.load_op_library("./my_reader_dataset_op.so")
+
+class MyReaderDataset(tf.data.Dataset):
+
+  def __init__(self):
+    super(MyReaderDataset, self).__init__()
+    # Create any input attrs or tensors as members of this class.
+
+  def _as_variant_tensor(self):
+    # Actually construct the graph node for the dataset op.
+    #
+    # This method will be invoked when you create an iterator on this dataset
+    # or a dataset derived from it.
+    return my_reader_dataset_module.my_reader_dataset()
+
+  # The following properties define the structure of each element: a scalar
+  # `tf.string` tensor. Change these properties to match the `output_dtypes()`
+  # and `output_shapes()` methods of `MyReaderDataset::Dataset` if you modify
+  # the structure of each element.
+  @property
+  def output_types(self):
+    return tf.string
+
+  @property
+  def output_shapes(self):
+    return tf.TensorShape([])
+
+  @property
+  def output_classes(self):
+    return tf.Tensor
+
+if __name__ == "__main__":
+  # Create a MyReaderDataset and print its elements.
+  with tf.Session() as sess:
+    iterator = MyReaderDataset().make_one_shot_iterator()
+    next_element = iterator.get_next()
+    try:
+      while True:
+        print(sess.run(next_element))  # Prints "MyReader!" ten times.
+    except tf.errors.OutOfRangeError:
+      pass
 ```
 
-You can see some examples in
-[`tensorflow/python/ops/io_ops.py`](https://www.tensorflow.org/code/tensorflow/python/ops/io_ops.py).
+You can see some examples of `Dataset` wrapper classes in
+[`tensorflow/python/data/ops/dataset_ops.py`](https://www.tensorflow.org/code/tensorflow/python/data/ops/dataset_ops.py).
 
 ## Writing an Op for a record format
 
@@ -201,9 +287,7 @@ track down where the bad data came from.
 
 Examples of Ops useful for decoding records:
 
-*   @{tf.parse_single_example}
-    (and
-    @{tf.parse_example})
+*   @{tf.parse_single_example} (and @{tf.parse_example})
 *   @{tf.decode_csv}
 *   @{tf.decode_raw}
 
@@ -211,11 +295,6 @@ Note that it can be useful to use multiple Ops to decode a particular record
 format.  For example, you may have an image saved as a string in
 [a `tf.train.Example` protocol buffer](https://www.tensorflow.org/code/tensorflow/core/example/example.proto).
 Depending on the format of that image, you might take the corresponding output
-from a
-@{tf.parse_single_example}
-op and call @{tf.image.decode_jpeg},
-@{tf.image.decode_png}, or
-@{tf.decode_raw}.  It is common to
-take the output of `tf.decode_raw` and use
-@{tf.slice} and
-@{tf.reshape} to extract pieces.
+from a @{tf.parse_single_example} op and call @{tf.image.decode_jpeg},
+@{tf.image.decode_png}, or @{tf.decode_raw}.  It is common to take the output
+of `tf.decode_raw` and use @{tf.slice} and @{tf.reshape} to extract pieces.
diff --git a/get_started/custom_estimators.md b/get_started/custom_estimators.md
index 941c3e1..275cda1 100644
--- a/get_started/custom_estimators.md
+++ b/get_started/custom_estimators.md
@@ -546,7 +546,7 @@ In brief, here's what the three graphs tell you:
 
 * accuracy: The accuracy is recorded by the following two lines:
 
-    * `eval_metric_ops={'my_accuracy': accuracy})`, during evaluation.
+    * `eval_metric_ops={'my_accuracy': accuracy}`, during evaluation.
     * `tf.summary.scalar('accuracy', accuracy[1])`, during training.
 
 These tensorboard graphs are one of the main reasons it's important to pass a
diff --git a/get_started/eager.md b/get_started/eager.md
new file mode 100644
index 0000000..ad89f01
--- /dev/null
+++ b/get_started/eager.md
@@ -0,0 +1,3 @@
+# Get Started with Eager Execution
+
+[Colab notebook](https://colab.research.google.com/github/tensorflow/models/blob/master/samples/core/get_started/eager.ipynb)
diff --git a/get_started/get_started_for_beginners.md b/get_started/get_started_for_beginners.md
index b88483b..fbe0ed7 100644
--- a/get_started/get_started_for_beginners.md
+++ b/get_started/get_started_for_beginners.md
@@ -1,4 +1,4 @@
-# Getting Started for ML Beginners
+# Get Started with Graph Execution
 
 This document explains how to use machine learning to classify (categorize)
 Iris flowers by species.  This document dives deeply into the TensorFlow
@@ -14,6 +14,11 @@ If you are already familiar with basic machine learning concepts
 but are new to TensorFlow, read
 @{$premade_estimators$Getting Started with TensorFlow: for ML Experts}.
 
+If you'd like to learn a lot about the basics of Machine Learning,
+consider taking
+[Machine Learning Crash Course](https://developers.google.com/machine-learning/crash-course/).
+
+
 ## The Iris classification problem
 
 Imagine you are a botanist seeking an automated way to classify each
@@ -86,6 +91,9 @@ a number.  Here's the representation scheme:
 * 1 represents versicolor
 * 2 represents virginica
 
+For a look at other examples of labels and examples, see the
+[ML Terminology section of Machine Learning Crash Course](https://developers.google.com/machine-learning/crash-course/framing/ml-terminology).
+
 
 ## Models and training
 
@@ -371,7 +379,7 @@ There are several categories of neural networks.
 We'll be using a [**fully connected neural
 network**](https://developers.google.com/machine-learning/glossary/#fully_connected_layer),
 which means that the neurons in one layer take inputs from *every* neuron in
-the previous layer.  For example, the following figure illustrates a 
+the previous layer.  For example, the following figure illustrates a
 fully connected neural network consisting of three hidden layers:
 
 *   The first hidden layer contains four neurons.
@@ -385,6 +393,9 @@ fully connected neural network consisting of three hidden layers:
 **A neural network with three hidden layers.**
 <p>&nbsp;</p>
 
+For a more detailed introduction to neural networks, see the
+[Introduction to Neural Nets section of Machine Learning Crash Course](https://developers.google.com/machine-learning/crash-course/introduction-to-neural-networks/anatomy).
+
 To specify a model type, instantiate an
 [**Estimator**](https://developers.google.com/machine-learning/glossary/#Estimators)
 class.  TensorFlow provides two categories of Estimators:
@@ -448,9 +459,9 @@ will become very important.
 
 ### Train the model
 
-Instantiating a `tf.Estimator.DNNClassifier` creates a framework for learning 
-the model. Basically, we've wired a network but haven't yet let data flow 
-through it. To train the neural network, call the Estimator object's `train` 
+Instantiating a `tf.Estimator.DNNClassifier` creates a framework for learning
+the model. Basically, we've wired a network but haven't yet let data flow
+through it. To train the neural network, call the Estimator object's `train`
 method. For example:
 
 ```python
@@ -559,15 +570,15 @@ of 0.5.  The following suggests a more effective model:
     <th colspan="1">Label</th>
     <th colspan="1">Prediction</th>
   </tr>
-  <tr> <td>5.9</td> <td>3.0</td> <td>4.3</td> <td>1.5</td> <td>1</td> 
+  <tr> <td>5.9</td> <td>3.0</td> <td>4.3</td> <td>1.5</td> <td>1</td>
           <td style="background-color:green">1</td></tr>
-  <tr> <td>6.9</td> <td>3.1</td> <td>5.4</td> <td>2.1</td> <td>2</td> 
+  <tr> <td>6.9</td> <td>3.1</td> <td>5.4</td> <td>2.1</td> <td>2</td>
           <td style="background-color:green">2</td></tr>
-  <tr> <td>5.1</td> <td>3.3</td> <td>1.7</td> <td>0.5</td> <td>0</td> 
+  <tr> <td>5.1</td> <td>3.3</td> <td>1.7</td> <td>0.5</td> <td>0</td>
           <td style="background-color:green">0</td></tr>
-  <tr> <td>6.0</td> <td>3.4</td> <td>4.5</td> <td>1.6</td> <td>1</td> 
+  <tr> <td>6.0</td> <td>3.4</td> <td>4.5</td> <td>1.6</td> <td>1</td>
           <td style="background-color:red">2</td></tr>
-  <tr> <td>5.5</td> <td>2.5</td> <td>4.0</td> <td>1.3</td> <td>1</td> 
+  <tr> <td>5.5</td> <td>2.5</td> <td>4.0</td> <td>1.3</td> <td>1</td>
           <td style="background-color:green">1</td></tr>
 </table>
 
@@ -631,6 +642,10 @@ Test set accuracy: 0.967
 An accuracy of 0.967 implies that our trained model correctly classified 29
 out of the 30 Iris species in the test set.
 
+To get a deeper understanding of different metrics for evaluating
+models, see the
+[Classification section of Machine Learning Crash Course](https://developers.google.com/machine-learning/crash-course/classification).
+
 
 ### Predicting
 
@@ -723,7 +738,6 @@ Prediction is "Virginica" (97.9%), expected "Virginica"
 
 ## Summary
 
-<!--TODO(barryr): When MLCC is released, add pointers to relevant sections.-->
 This document provides a short introduction to machine learning.
 
 Because `premade_estimators.py` relies on high-level APIs, much of the
diff --git a/get_started/index.md b/get_started/index.md
index b7bd128..b28cb9d 100644
--- a/get_started/index.md
+++ b/get_started/index.md
@@ -1,10 +1,22 @@
-# Getting Started
+# Get Started
+
+If you are new to machine learning, we recommend taking the following online
+course prior to diving into TensorFlow documentation:
+
+  * [Machine Learning Crash Course](https://developers.google.com/machine-learning/crash-course/),
+    which introduces machine learning concepts and encourages experimentation
+    with existing TensorFlow code.
 
 TensorFlow is a tool for machine learning. While it contains a wide range of
 functionality, TensorFlow is mainly designed for deep neural network models.
 
-TensorFlow provides many APIs. This section focuses on the high-level APIs.
-If you are new to TensorFlow, begin by reading one of the following documents:
+The easiest way to get started with tensorflow is using Eager Execution.
+
+  * @{$get_started/eager}, is for anyone new to  machine learning or TensorFlow.
+
+TensorFlow provides many APIs. The remainder of this section focuses on the
+Estimator API which provide scalable, high-performance models.
+To get started with Estimators begin by reading one of the following documents:
 
   * @{$get_started/get_started_for_beginners}, which is aimed at readers
     new to machine learning.
diff --git a/get_started/leftnav_files b/get_started/leftnav_files
index 437791d..4c12f0d 100644
--- a/get_started/leftnav_files
+++ b/get_started/leftnav_files
@@ -1,10 +1,14 @@
 index.md
 
-### Getting Started
+### Beginners
+eager.md
 get_started_for_beginners.md
 premade_estimators.md
 
-### Details
+### Estimators
+get_started_for_beginners.md: For Beginners
+premade_estimators.md: Premade Estimators
+>>>
 checkpoints.md
 feature_columns.md
 datasets_quickstart.md
diff --git a/get_started/premade_estimators.md b/get_started/premade_estimators.md
index 6bffd2e..4be7e50 100644
--- a/get_started/premade_estimators.md
+++ b/get_started/premade_estimators.md
@@ -1,5 +1,4 @@
-
-# Getting Started with TensorFlow
+# Premade Estimators
 
 This document introduces the TensorFlow programming environment and shows you
 how to solve the Iris classification problem in TensorFlow.
@@ -397,9 +396,9 @@ predictions and their probabilities:
 
 
 ``` python
-for pred_dict, expec in zip(predictions, expected):
-    template = ('\nPrediction is "{}" ({:.1f}%), expected "{}"')
+template = ('\nPrediction is "{}" ({:.1f}%), expected "{}"')
 
+for pred_dict, expec in zip(predictions, expected):
     class_id = pred_dict['class_ids'][0]
     probability = pred_dict['probabilities'][class_id]
 
diff --git a/install/install_c.md b/install/install_c.md
index 9059b3f..8c165aa 100644
--- a/install/install_c.md
+++ b/install/install_c.md
@@ -38,7 +38,7 @@ enable TensorFlow for C:
          OS="linux" # Change to "darwin" for macOS
          TARGET_DIRECTORY="/usr/local"
          curl -L \
-           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-$%7BTF_TYPE%7D-$%7BOS%7D-x86_64-1.7.0-rc1.tar.gz" |
+           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-$%7BTF_TYPE%7D-$%7BOS%7D-x86_64-1.8.0-rc1.tar.gz" |
            sudo tar -C $TARGET_DIRECTORY -xz
 
      The `tar` command extracts the TensorFlow C library into the `lib`
@@ -113,6 +113,6 @@ If executing `a.out` fails, ask yourself the following questions:
   * Did you export those environment variables?
 
 If you are still seeing build or execution error messages, search (or post to)
-[StackOverflow](www.stackoverflow.com/questions/tagged/tensorflow) for
+[StackOverflow](https://stackoverflow.com/questions/tagged/tensorflow) for
 possible solutions.
 
diff --git a/install/install_go.md b/install/install_go.md
index 2e47a6d..26cbcc9 100644
--- a/install/install_go.md
+++ b/install/install_go.md
@@ -38,7 +38,7 @@ steps to install this library and enable TensorFlow for Go:
          TF_TYPE="cpu" # Change to "gpu" for GPU support
          TARGET_DIRECTORY='/usr/local'
          curl -L \
-           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-$%7BTF_TYPE%7D-$(go%20env%20GOOS)-x86_64-1.7.0-rc1.tar.gz" |
+           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-$%7BTF_TYPE%7D-$(go%20env%20GOOS)-x86_64-1.8.0-rc1.tar.gz" |
          sudo tar -C $TARGET_DIRECTORY -xz
 
      The `tar` command extracts the TensorFlow C library into the `lib`
diff --git a/install/install_java.md b/install/install_java.md
index eff066d..1b0bbdb 100644
--- a/install/install_java.md
+++ b/install/install_java.md
@@ -36,7 +36,7 @@ following to the project's `pom.xml` to use the TensorFlow Java APIs:
 <dependency>
   <groupId>org.tensorflow</groupId>
   <artifactId>tensorflow</artifactId>
-  <version>1.7.0-rc1</version>
+  <version>1.8.0-rc1</version>
 </dependency>
 ```
 
@@ -65,7 +65,7 @@ As an example, these steps will create a Maven project that uses TensorFlow:
                <dependency>
                  <groupId>org.tensorflow</groupId>
                  <artifactId>tensorflow</artifactId>
-                 <version>1.7.0-rc1</version>
+                 <version>1.8.0-rc1</version>
                </dependency>
              </dependencies>
          </project>
@@ -123,12 +123,12 @@ instead:
 <dependency>
   <groupId>org.tensorflow</groupId>
   <artifactId>libtensorflow</artifactId>
-  <version>1.7.0-rc1</version>
+  <version>1.8.0-rc1</version>
 </dependency>
 <dependency>
   <groupId>org.tensorflow</groupId>
   <artifactId>libtensorflow_jni_gpu</artifactId>
-  <version>1.7.0-rc1</version>
+  <version>1.8.0-rc1</version>
 </dependency>
 ```
 
@@ -147,7 +147,7 @@ refer to the simpler instructions above instead.
 Take the following steps to install TensorFlow for Java on Linux or macOS:
 
   1. Download
-     [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.7.0-rc1.jar),
+     [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.8.0-rc1.jar),
      which is the TensorFlow Java Archive (JAR).
 
   2. Decide whether you will run TensorFlow for Java on CPU(s) only or with
@@ -166,7 +166,7 @@ Take the following steps to install TensorFlow for Java on Linux or macOS:
          OS=$(uname -s | tr '[:upper:]' '[:lower:]')
          mkdir -p ./jni
          curl -L \
-           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-$%7BTF_TYPE%7D-$%7BOS%7D-x86_64-1.7.0-rc1.tar.gz" |
+           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-$%7BTF_TYPE%7D-$%7BOS%7D-x86_64-1.8.0-rc1.tar.gz" |
            tar -xz -C ./jni
 
 ### Install on Windows
@@ -174,10 +174,10 @@ Take the following steps to install TensorFlow for Java on Linux or macOS:
 Take the following steps to install TensorFlow for Java on Windows:
 
   1. Download
-     [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.7.0-rc1.jar),
+     [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.8.0-rc1.jar),
      which is the TensorFlow Java Archive (JAR).
   2. Download the following Java Native Interface (JNI) file appropriate for
-     [TensorFlow for Java on Windows](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-cpu-windows-x86_64-1.7.0-rc1.zip).
+     [TensorFlow for Java on Windows](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-cpu-windows-x86_64-1.8.0-rc1.zip).
   3. Extract this .zip file.
 
 
@@ -225,7 +225,7 @@ must be part of your `classpath`. For example, you can include the
 downloaded `.jar` in your `classpath` by using the `-cp` compilation flag
 as follows:
 
-<pre><b>javac -cp libtensorflow-1.7.0-rc1.jar HelloTF.java</b></pre>
+<pre><b>javac -cp libtensorflow-1.8.0-rc1.jar HelloTF.java</b></pre>
 
 
 ### Running
@@ -239,11 +239,11 @@ two files are available to the JVM:
 For example, the following command line executes the `HelloTF` program on Linux
 and macOS X:
 
-<pre><b>java -cp libtensorflow-1.7.0-rc1.jar:. -Djava.library.path=./jni HelloTF</b></pre>
+<pre><b>java -cp libtensorflow-1.8.0-rc1.jar:. -Djava.library.path=./jni HelloTF</b></pre>
 
 And the following command line executes the `HelloTF` program on Windows:
 
-<pre><b>java -cp libtensorflow-1.7.0-rc1.jar;. -Djava.library.path=jni HelloTF</b></pre>
+<pre><b>java -cp libtensorflow-1.8.0-rc1.jar;. -Djava.library.path=jni HelloTF</b></pre>
 
 If the program prints <tt>Hello from <i>version</i></tt>, you've successfully
 installed TensorFlow for Java and are ready to use the API.  If the program
diff --git a/install/install_linux.md b/install/install_linux.md
index 378946b..f19f827 100644
--- a/install/install_linux.md
+++ b/install/install_linux.md
@@ -31,20 +31,21 @@ If you are installing TensorFlow with GPU support using one of the
 mechanisms described in this guide, then the following NVIDIA software
 must be installed on your system:
 
-  * CUDA® Toolkit 9.0. For details, see
-    [NVIDIA's documentation](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/#axzz4VZnqTJ2A).
-    Ensure that you append the relevant Cuda pathnames to the
+  * [CUDA Toolkit 9.0](http://nvidia.com/cuda). For details, see
+    [NVIDIA's documentation](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/).
+    Ensure that you append the relevant CUDA pathnames to the
     `LD_LIBRARY_PATH` environment variable as described in the
     NVIDIA documentation.
-  * The NVIDIA drivers associated with CUDA Toolkit 9.0.
-  * cuDNN v7.0. For details, see
-    [NVIDIA's documentation](https://developer.nvidia.com/cudnn).
+  * [cuDNN SDK v7](http://developer.nvidia.com/cudnn). For details, see
+    [NVIDIA's documentation](http://docs.nvidia.com/deeplearning/sdk/cudnn-install/).
     Ensure that you create the `CUDA_HOME` environment variable as
     described in the NVIDIA documentation.
   * GPU card with CUDA Compute Capability 3.0 or higher for building
     from source and 3.5 or higher for our binaries. See
     [NVIDIA documentation](https://developer.nvidia.com/cuda-gpus) for
     a list of supported GPU cards.
+  * [GPU drivers](http://nvidia.com/driver) supporting your version of the CUDA
+    Toolkit.
   * The libcupti-dev library, which is the NVIDIA CUDA Profile Tools Interface.
     This library provides advanced profiling support. To install this library,
     issue the following command for CUDA Toolkit >= 8.0:
@@ -56,7 +57,7 @@ must be installed on your system:
     and add its path to your `LD_LIBRARY_PATH` environment variable:
 
     <pre>
-    $ <b>export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/extras/CUPTI/lib64</b>
+    $ <b>export LD_LIBRARY_PATH=${LD_LIBRARY_PATH:+${LD_LIBRARY_PATH}:}/usr/local/cuda/extras/CUPTI/lib64</b>
     </pre>
 
     For CUDA Toolkit <= 7.5 do:
@@ -64,17 +65,20 @@ must be installed on your system:
     <pre>
     $ <b>sudo apt-get install libcupti-dev</b>
     </pre>
+  * **[OPTIONAL]**  For optimized inferencing performance, you can also install
+    NVIDIA TensorRT 3.0. For details, see
+    [NVIDIA's TensorRT documentation](http://docs.nvidia.com/deeplearning/sdk/tensorrt-install-guide/index.html#installing-tar).
+    Only steps 1-4 in the TensorRT Tar File installation instructions are
+    required for compatibility with TensorFlow; the Python package installation
+    in steps 5 and 6 can be omitted. Detailed installation instructions can be found at [package documentataion](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/tensorrt#installing-tensorrt-304)
+
+    **IMPORTANT:** For compatibility with the pre-built `tensorflow-gpu`
+    package, please use the Ubuntu **14.04** tar file package of TensorRT
+    even when installing onto an Ubuntu 16.04 system.   
 
 If you have an earlier version of the preceding packages, please upgrade to
 the specified versions. If upgrading is not possible, then you may still run
-TensorFlow with GPU support, but only if you do the following:
-
-  * Install TensorFlow from sources as documented in
-    @{$install_sources$Installing TensorFlow from Sources}.
-  * Install or upgrade to at least the following NVIDIA versions:
-    * CUDA toolkit 7.0 or greater
-    * cuDNN v3 or greater
-    * GPU card with CUDA Compute Capability 3.0 or higher.
+TensorFlow with GPU support, if you @{$install_sources$install TensorFlow from Sources}.
 
 
 ## Determine how to install TensorFlow
@@ -149,7 +153,8 @@ Take the following steps to install TensorFlow with Virtualenv:
      commands:
 
      <pre>$ <b>source ~/tensorflow/bin/activate</b> # bash, sh, ksh, or zsh
-    $ <b>source ~/tensorflow/bin/activate.csh</b>  # csh or tcsh</pre>
+    $ <b>source ~/tensorflow/bin/activate.csh</b>  # csh or tcsh
+    $ <b>. ~/tensorflow/bin/activate.fish</b>  # fish</pre>
 
      The preceding <tt>source</tt> command should change your prompt
      to the following:
@@ -189,7 +194,7 @@ Take the following steps to install TensorFlow with Virtualenv:
      Virtualenv environment:
 
      <pre>(tensorflow)$ <b>pip3 install --upgrade \
-     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.7.0rc1-cp34-cp34m-linux_x86_64.whl</b></pre>
+     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0rc1-cp34-cp34m-linux_x86_64.whl</b></pre>
 
 If you encounter installation problems, see
 [Common Installation Problems](#common_installation_problems).
@@ -294,7 +299,7 @@ take the following steps:
 
      <pre>
      $ <b>sudo pip3 install --upgrade \
-     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.7.0rc1-cp34-cp34m-linux_x86_64.whl</b>
+     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0rc1-cp34-cp34m-linux_x86_64.whl</b>
      </pre>
 
      If this step fails, see
@@ -480,7 +485,7 @@ Take the following steps to install TensorFlow in an Anaconda environment:
 
      <pre>
      (tensorflow)$ <b>pip install --ignore-installed --upgrade \
-     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.7.0rc1-cp34-cp34m-linux_x86_64.whl</b></pre>
+     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0rc1-cp34-cp34m-linux_x86_64.whl</b></pre>
 
 <a name="ValidateYourInstallation"></a>
 ## Validate your installation
@@ -530,11 +535,18 @@ TensorFlow programs:
 
 <pre>Hello, TensorFlow!</pre>
 
-If you are new to TensorFlow, see @{$get_started/premade_estimators$Getting Started with TensorFlow}.
-
 If the system outputs an error message instead of a greeting, see [Common
 installation problems](#common_installation_problems).
 
+If you are new to machine learning, we recommend the following:
+
+*  [Machine Learning Crash Course](https://developers.google.com/machine-learning/crash-course)
+*  @{$get_started/get_started_for_beginners$Getting Started for ML Beginners}
+
+If you are experienced with machine learning but new to TensorFlow, see
+@{$get_started/premade_estimators$Getting Started with TensorFlow}.
+
+
 ## Common installation problems
 
 We are relying on Stack Overflow to document TensorFlow installation problems
@@ -647,14 +659,14 @@ This section documents the relevant values for Linux installations.
 CPU only:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.7.0rc1-cp27-none-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0rc1-cp27-none-linux_x86_64.whl
 </pre>
 
 
 GPU support:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.7.0rc1-cp27-none-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.8.0rc1-cp27-none-linux_x86_64.whl
 </pre>
 
 Note that GPU support requires the NVIDIA hardware and software described in
@@ -666,14 +678,14 @@ Note that GPU support requires the NVIDIA hardware and software described in
 CPU only:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.7.0rc1-cp34-cp34m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0rc1-cp34-cp34m-linux_x86_64.whl
 </pre>
 
 
 GPU support:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.7.0rc1-cp34-cp34m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.8.0rc1-cp34-cp34m-linux_x86_64.whl
 </pre>
 
 Note that GPU support requires the NVIDIA hardware and software described in
@@ -685,14 +697,14 @@ Note that GPU support requires the NVIDIA hardware and software described in
 CPU only:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.7.0rc1-cp35-cp35m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0rc1-cp35-cp35m-linux_x86_64.whl
 </pre>
 
 
 GPU support:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.7.0rc1-cp35-cp35m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.8.0rc1-cp35-cp35m-linux_x86_64.whl
 </pre>
 
 
@@ -704,14 +716,14 @@ Note that GPU support requires the NVIDIA hardware and software described in
 CPU only:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.7.0rc1-cp36-cp36m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0rc1-cp36-cp36m-linux_x86_64.whl
 </pre>
 
 
 GPU support:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.7.0rc1-cp36-cp36m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.8.0rc1-cp36-cp36m-linux_x86_64.whl
 </pre>
 
 
diff --git a/install/install_mac.md b/install/install_mac.md
index fa6951a..ff6c2f5 100644
--- a/install/install_mac.md
+++ b/install/install_mac.md
@@ -119,7 +119,7 @@ Take the following steps to install TensorFlow with Virtualenv:
      TensorFlow in the active Virtualenv is as follows:
 
      <pre> $ <b>pip3 install --upgrade \
-     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.7.0rc1-py3-none-any.whl</b></pre>
+     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.8.0rc1-py3-none-any.whl</b></pre>
 
 If you encounter installation problems, see
 [Common Installation Problems](#common-installation-problems).
@@ -238,11 +238,11 @@ take the following steps:
      operating system and Python version. Find the appropriate
      value for <i>tfBinaryURL</i>
      [here](#the_url_of_the_tensorflow_python_package).  For example, if
-     you are installing TensorFlow for Mac OS and Python 2.7
+     you are installing TensorFlow for macOS and Python 2.7
      issue the following command:
 
      <pre> $ <b>sudo pip3 install --upgrade \
-     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.7.0rc1-py3-none-any.whl</b> </pre>
+     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.8.0rc1-py3-none-any.whl</b> </pre>
 
      If the preceding command fails, see
      [installation problems](#common-installation-problems).
@@ -350,7 +350,7 @@ Take the following steps to install TensorFlow in an Anaconda environment:
      TensorFlow for Python 2.7:
 
      <pre> (<i>targetDirectory</i>)$ <b>pip install --ignore-installed --upgrade \
-     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.7.0rc1-py2-none-any.whl</b></pre>
+     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.8.0rc1-py2-none-any.whl</b></pre>
 
 
 <a name="ValidateYourInstallation"></a>
@@ -400,12 +400,18 @@ writing TensorFlow programs:
 
 <pre>Hello, TensorFlow!</pre>
 
-If you are new to TensorFlow, see
-@{$get_started/premade_estimators$Getting Started with TensorFlow}.
-
 If the system outputs an error message instead of a greeting, see
 [Common installation problems](#common_installation_problems).
 
+If you are new to machine learning, we recommend the following:
+
+*  [Machine Learning Crash Course](https://developers.google.com/machine-learning/crash-course)
+*  @{$get_started/get_started_for_beginners$Getting Started for ML Beginners}
+
+If you are experienced with machine learning but new to TensorFlow, see
+@{$get_started/premade_estimators$Getting Started with TensorFlow}.
+
+
 ## Common installation problems
 
 We are relying on Stack Overflow to document TensorFlow installation problems
@@ -512,18 +518,13 @@ RuntimeError: Broken toolchain: cannot link a simple C program</pre>
 ## The URL of the TensorFlow Python package
 
 A few installation mechanisms require the URL of the TensorFlow Python package.
-The value you specify depends on three factors:
-
-  * operating system
-  * Python version
-
-This section documents the relevant values for Mac OS installations.
+The value you specify depends on your Python version.
 
 ### Python 2.7
 
 
 <pre>
-https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.7.0rc1-py2-none-any.whl
+https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.8.0rc1-py2-none-any.whl
 </pre>
 
 
@@ -531,5 +532,5 @@ https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.7.0rc1-py2-none-a
 
 
 <pre>
-https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.7.0rc1-py3-none-any.whl
+https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.8.0rc1-py3-none-any.whl
 </pre>
diff --git a/install/install_sources.md b/install/install_sources.md
index 0454c17..d48a6ee 100644
--- a/install/install_sources.md
+++ b/install/install_sources.md
@@ -133,30 +133,21 @@ The following NVIDIA <i>hardware</i> must be installed on your system:
 
 The following NVIDIA <i>software</i> must be installed on your system:
 
-  * NVIDIA's Cuda Toolkit (>= 7.0). We recommend version 9.0.
+  * [CUDA Toolkit](http://nvidia.com/cuda) (>= 7.0). We recommend version 9.0.
     For details, see
-    [NVIDIA's documentation](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/#axzz4VZnqTJ2A).
-    Ensure that you append the relevant Cuda pathnames to the
+    [NVIDIA's documentation](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/).
+    Ensure that you append the relevant CUDA pathnames to the
     `LD_LIBRARY_PATH` environment variable as described in the
     NVIDIA documentation.
-  * The NVIDIA drivers associated with NVIDIA's Cuda Toolkit.
-  * cuDNN (>= v3). We recommend version 6.0. For details, see
-    [NVIDIA's documentation](https://developer.nvidia.com/cudnn),
-    particularly the description of appending the appropriate pathname
-    to your `LD_LIBRARY_PATH` environment variable.
-
-Finally, you must also install `libcupti` which for Cuda Toolkit >= 8.0 you do via
-
-<pre> $ <b>sudo apt-get install cuda-command-line-tools</b> </pre>
-
-and add its path to your `LD_LIBRARY_PATH` environment variable:
-
-<pre> $ <b>export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/extras/CUPTI/lib64</b> </pre>
-
-For Cuda Toolkit <= 7.5, you install `libcupti-dev` by invoking the following command:
-
-<pre> $ <b>sudo apt-get install libcupti-dev</b> </pre>
+  * [GPU drivers](http://nvidia.com/driver) supporting your version of the CUDA
+    Toolkit.
+  * [cuDNN SDK](http://developer.nvidia.com/cudnn) (>= v3). We recommend version 7.0. For details, see
+    [NVIDIA's documentation](http://docs.nvidia.com/deeplearning/sdk/cudnn-install/).
+  * [CUPTI](http://docs.nvidia.com/cuda/cupti/) ships with the CUDA Toolkit, but
+    you also need to append its path to the `LD_LIBRARY_PATH` environment
+    variable:
 
+    <pre> $ <b>export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/extras/CUPTI/lib64</b> </pre>
 
 ### Next
 
@@ -240,8 +231,8 @@ such as compiler flags. You must run this script *prior* to
 creating the pip package and installing TensorFlow.
 
 If you wish to build TensorFlow with GPU, `configure` will ask
-you to specify the version numbers of Cuda and cuDNN. If several
-versions of Cuda or cuDNN are installed on your system, explicitly select
+you to specify the version numbers of CUDA and cuDNN. If several
+versions of CUDA or cuDNN are installed on your system, explicitly select
 the desired version instead of relying on the default.
 
 One of the questions that `configure` will ask is as follows:
@@ -289,12 +280,12 @@ Do you wish to build TensorFlow with CUDA support? [y/N] <b>Y</b>
 CUDA support will be enabled for TensorFlow
 Do you want to use clang as CUDA compiler? [y/N]
 nvcc will be used as CUDA compiler
-Please specify the Cuda SDK version you want to use, e.g. 7.0. [Leave empty to default to CUDA 9.0]: <b>9.0</b>
+Please specify the CUDA SDK version you want to use, e.g. 7.0. [Leave empty to default to CUDA 9.0]: <b>9.0</b>
 Please specify the location where CUDA 9.0 toolkit is installed. Refer to README.md for more details. [Default is /usr/local/cuda]:
 Please specify which gcc should be used by nvcc as the host compiler. [Default is /usr/bin/gcc]:
 Please specify the cuDNN version you want to use. [Leave empty to default to cuDNN 7.0]: <b>7</b>
 Please specify the location where cuDNN 7 library is installed. Refer to README.md for more details. [Default is /usr/local/cuda]:
-Please specify a list of comma-separated Cuda compute capabilities you want to build with.
+Please specify a list of comma-separated CUDA compute capabilities you want to build with.
 You can find the compute capability of your device at: https://developer.nvidia.com/cuda-gpus.
 Please note that each additional compute capability significantly increases your build time and binary size.
 [Default is: "3.5,5.2"]: <b>3.0</b>
@@ -304,14 +295,14 @@ Configuration finished
 </pre>
 
 If you told `configure` to build for GPU support, then `configure`
-will create a canonical set of symbolic links to the Cuda libraries
-on your system.  Therefore, every time you change the Cuda library paths,
+will create a canonical set of symbolic links to the CUDA libraries
+on your system.  Therefore, every time you change the CUDA library paths,
 you must rerun the `configure` script before re-invoking
 the <code>bazel build</code> command.
 
 Note the following:
 
-  * Although it is possible to build both Cuda and non-Cuda configs
+  * Although it is possible to build both CUDA and non-CUDA configs
     under the same source tree, we recommend running `bazel clean` when
     switching between these two configurations in the same source tree.
   * If you don't run the `configure` script *before* running the
@@ -359,10 +350,10 @@ Invoke `pip install` to install that pip package.
 The filename of the `.whl` file depends on your platform.
 For example, the following command will install the pip package
 
-for TensorFlow 1.7.0rc1 on Linux:
+for TensorFlow 1.8.0rc1 on Linux:
 
 <pre>
-$ <b>sudo pip install /tmp/tensorflow_pkg/tensorflow-1.7.0rc1-py2-none-any.whl</b>
+$ <b>sudo pip install /tmp/tensorflow_pkg/tensorflow-1.8.0rc1-py2-none-any.whl</b>
 </pre>
 
 ## Validate your installation
@@ -459,8 +450,10 @@ Stack Overflow and specify the `tensorflow` tag.
 **Linux**
 <table>
 <tr><th>Version:</th><th>CPU/GPU:</th><th>Python Version:</th><th>Compiler:</th><th>Build Tools:</th><th>cuDNN:</th><th>CUDA:</th></tr>
-<tr><td>tensorflow-1.7.0rc1</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.10.0</td><td>N/A</td><td>N/A</td></tr>
-<tr><td>tensorflow_gpu-1.7.0rc1</td><td>GPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.9.0</td><td>7</td><td>9</td></tr>
+<tr><td>tensorflow-1.8.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.10.0</td><td>N/A</td><td>N/A</td></tr>
+<tr><td>tensorflow_gpu-1.8.0</td><td>GPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.9.0</td><td>7</td><td>9</td></tr>
+<tr><td>tensorflow-1.7.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.10.0</td><td>N/A</td><td>N/A</td></tr>
+<tr><td>tensorflow_gpu-1.7.0</td><td>GPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.9.0</td><td>7</td><td>9</td></tr>
 <tr><td>tensorflow-1.6.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.9.0</td><td>N/A</td><td>N/A</td></tr>
 <tr><td>tensorflow_gpu-1.6.0</td><td>GPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.9.0</td><td>7</td><td>9</td></tr>
 <tr><td>tensorflow-1.5.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.8.0</td><td>N/A</td><td>N/A</td></tr>
@@ -480,7 +473,8 @@ Stack Overflow and specify the `tensorflow` tag.
 **Mac**
 <table>
 <tr><th>Version:</th><th>CPU/GPU:</th><th>Python Version:</th><th>Compiler:</th><th>Build Tools:</th><th>cuDNN:</th><th>CUDA:</th></tr>
-<tr><td>tensorflow-1.7.0rc1</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>Clang from xcode</td><td>Bazel 0.10.1</td><td>N/A</td><td>N/A</td></tr>
+<tr><td>tensorflow-1.8.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>Clang from xcode</td><td>Bazel 0.10.1</td><td>N/A</td><td>N/A</td></tr>
+<tr><td>tensorflow-1.7.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>Clang from xcode</td><td>Bazel 0.10.1</td><td>N/A</td><td>N/A</td></tr>
 <tr><td>tensorflow-1.6.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>Clang from xcode</td><td>Bazel 0.8.1</td><td>N/A</td><td>N/A</td></tr>
 <tr><td>tensorflow-1.5.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>Clang from xcode</td><td>Bazel 0.8.1</td><td>N/A</td><td>N/A</td></tr>
 <tr><td>tensorflow-1.4.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>Clang from xcode</td><td>Bazel 0.5.4</td><td>N/A</td><td>N/A</td></tr>
@@ -495,8 +489,10 @@ Stack Overflow and specify the `tensorflow` tag.
 **Windows**
 <table>
 <tr><th>Version:</th><th>CPU/GPU:</th><th>Python Version:</th><th>Compiler:</th><th>Build Tools:</th><th>cuDNN:</th><th>CUDA:</th></tr>
-<tr><td>tensorflow-1.7.0rc1</td><td>CPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>N/A</td><td>N/A</td></tr>
-<tr><td>tensorflow_gpu-1.7.0rc1</td><td>GPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>7</td><td>9</td></tr>
+<tr><td>tensorflow-1.8.0</td><td>CPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>N/A</td><td>N/A</td></tr>
+<tr><td>tensorflow_gpu-1.8.0</td><td>GPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>7</td><td>9</td></tr>
+<tr><td>tensorflow-1.7.0</td><td>CPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>N/A</td><td>N/A</td></tr>
+<tr><td>tensorflow_gpu-1.7.0</td><td>GPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>7</td><td>9</td></tr>
 <tr><td>tensorflow-1.6.0</td><td>CPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>N/A</td><td>N/A</td></tr>
 <tr><td>tensorflow_gpu-1.6.0</td><td>GPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>7</td><td>9</td></tr>
 <tr><td>tensorflow-1.5.0</td><td>CPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>N/A</td><td>N/A</td></tr>
diff --git a/install/install_windows.md b/install/install_windows.md
index 2413bc9..86add74 100644
--- a/install/install_windows.md
+++ b/install/install_windows.md
@@ -17,7 +17,7 @@ You must choose one of the following types of TensorFlow to install:
     NVIDIA® GPU, you must install this version. Note that this version of
     TensorFlow is typically much easier to install (typically,
     in 5 or 10 minutes), so even if you have an NVIDIA GPU, we recommend
-    installing this version first. Prebuilt binaries will use AVX instructions. 
+    installing this version first. Prebuilt binaries will use AVX instructions.
   * **TensorFlow with GPU support**. TensorFlow programs typically run
     significantly faster on a GPU than on a CPU. Therefore, if your
     system has a NVIDIA® GPU meeting the prerequisites shown below
@@ -154,13 +154,17 @@ TensorFlow programs:
 
 <pre>Hello, TensorFlow!</pre>
 
-If you are new to TensorFlow, see @{$get_started/premade_estimators$Getting Started with TensorFlow}.
-
 If the system outputs an error message instead of a greeting, see [Common
 installation problems](#common_installation_problems).
 
-There is also a helpful [script](https://gist.github.com/mrry/ee5dbcfdd045fa48a27d56664411d41c)
-for Windows TensorFlow installation issues.
+If you are new to machine learning, we recommend the following:
+
+*  [Machine Learning Crash Course](https://developers.google.com/machine-learning/crash-course)
+*  @{$get_started/get_started_for_beginners$Getting Started for ML Beginners}
+
+If you are experienced with machine learning but new to TensorFlow, see
+@{$get_started/premade_estimators$Getting Started with TensorFlow}.
+
 
 ## Common installation problems
 
diff --git a/javascript/index.md b/javascript/index.md
new file mode 100644
index 0000000..ad63eeb
--- /dev/null
+++ b/javascript/index.md
@@ -0,0 +1,5 @@
+# JavaScript 
+
+You may develop TensorFlow programs in JavaScript, training and deploying
+models right in your browser.  For details, see
+[js.tensorflow.org](https://js.tensorflow.org).
diff --git a/javascript/leftnav_files b/javascript/leftnav_files
new file mode 100644
index 0000000..fc0ab8a
--- /dev/null
+++ b/javascript/leftnav_files
@@ -0,0 +1 @@
+index.md
diff --git a/mobile/leftnav_files b/mobile/leftnav_files
index 4cf134c..585470d 100644
--- a/mobile/leftnav_files
+++ b/mobile/leftnav_files
@@ -1,6 +1,7 @@
 index.md
 ### TensorFlow Lite
 tflite/index.md
+tflite/devguide.md
 tflite/demo_android.md
 tflite/demo_ios.md
 >>>
diff --git a/mobile/optimizing.md b/mobile/optimizing.md
index ca9cb04..778e4d3 100644
--- a/mobile/optimizing.md
+++ b/mobile/optimizing.md
@@ -233,6 +233,8 @@ order by how long they took. From left to right, the columns are:
 - The cumulative total time of this and the previous ops in the table. This is
   handy for understanding what the distribution of work is across the layers, to
   see if just a few of the nodes are taking up most of the time.
+  
+- The amount of memory consumed by outputs of this type of op.
 
 - Name of the node.
 
diff --git a/mobile/prepare_models.md b/mobile/prepare_models.md
index 360ee30..8b22c04 100644
--- a/mobile/prepare_models.md
+++ b/mobile/prepare_models.md
@@ -60,7 +60,7 @@ and serialized as protocol buffers:
   the `NodeDef`, so if all the `Variable` weights are converted to `Const` nodes,
   then we only need a single `GraphDef` file to hold the model architecture and
   the weights. Freezing the graph handles the process of loading the
-  checkpoints, and then converts all Consts to Variables. You can then load the
+  checkpoints, and then converts all Variables to Consts. You can then load the
   resulting file in a single call, without having to restore variable values
   from checkpoints. One thing to watch out for with `GraphDef` files is that
   sometimes they’re stored in text format for easy inspection. These versions
diff --git a/mobile/tflite/demo_android.md b/mobile/tflite/demo_android.md
index c94b559..7f2f888 100644
--- a/mobile/tflite/demo_android.md
+++ b/mobile/tflite/demo_android.md
@@ -1,42 +1,144 @@
-# TensorFlow Lite Demo for Android
+# Android Demo App
 
-The TensorFlow Lite demo is a camera app that continuously classifies whatever
-it sees from your device's back camera, using a quantized MobileNet model.
+An example Android application using TensorFLow Lite is available
+[on GitHub](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/lite/java/demo/app).
+The demo is a sample camera app that classifies images continuously
+using either a quantized Mobilenet model or a floating point Inception-v3 model.
+To run the demo, a device running Android 5.0 ( API 21) or higher is required.
 
-You'll need an Android device running Android 5.0 or higher to run the demo.
+In the demo app, inference is done using the TensorFlow Lite Java API. The demo
+app classifies frames in real-time, displaying the top most probable
+classifications. It also displays the time taken to detect the object.
 
-To get you started working with TensorFlow Lite on Android, we'll walk you
-through building and deploying our TensorFlow demo app in Android Studio.
+There are three ways to get the demo app to your device:
 
-Note: For a more detailed guide see the
-[TFLite Codelab](https://codelabs.developers.google.com/codelabs/tensorflow-for-poets-2-tflite/index.html#0)
+* Download the [prebuilt binary APK](http://download.tensorflow.org/deps/tflite/TfLiteCameraDemo.apk).
+* Use Android Studio to build the application.
+* Download the source code for TensorFlow Lite and the demo and build it using
+  bazel.
 
-It's also possible to build the demo app with Bazel, but we only recommend
-this for advanced users who are very familiar with the Bazel build
-environment. For more information on that, see our page [on Github](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/lite#building-tensorflow-lite-and-the-demo-app-from-source).
 
-## Build and deploy with Android Studio
+## Download the pre-built binary
 
-1. Clone the TensorFlow repository from GitHub if you haven't already:
+The easiest way to try the demo is to download the
+[pre-built binary APK](https://storage.googleapis.com/download.tensorflow.org/deps/tflite/TfLiteCameraDemo.apk)
 
-        git clone https://github.com/tensorflow/tensorflow
+Once the APK is installed, click the app icon to start the program. The first
+time the app is opened, it asks for runtime permissions to access the device
+camera. The demo app opens the back-camera of the device and recognizes objects
+in the camera's field of view. At the bottom of the image (or at the left
+of the image if the device is in landscape mode), it displays top three objects
+classified and the classification latency.
 
-2. Install the latest version of Android Studio from [here](https://developer.android.com/studio/index.html).
 
-3. From the **Welcome to Android Studio** screen, use the **Import Project
-   (Gradle, Eclipse ADT, etc)** option to import the
-   `tensorflow/contrib/lite/java/demo` directory as an existing Android Studio
-   Project.
+## Build in Android Studio with TensorFlow Lite AAR from JCenter
 
-    Android Studio may prompt you to install Gradle upgrades and other tool
-    versions; you should accept these upgrades.
+Use Android Studio to try out changes in the project code and compile the demo
+app:
 
-4. Download the TensorFlow Lite MobileNet model from [here](https://storage.googleapis.com/download.tensorflow.org/models/tflite/mobilenet_v1_224_android_quant_2017_11_08.zip).
+* Install the latest version of
+  [Android Studio](https://developer.android.com/studio/index.html).
+* Make sure the Android SDK version is greater than 26 and NDK version is greater
+  than 14 (in the Android Studio settings).
+* Import the `tensorflow/contrib/lite/java/demo` directory as a new
+  Android Studio project.
+* Install all the Gradle extensions it requests.
 
-    Unzip this and copy the `mobilenet_quant_v1_224.tflite` file to the assets
-    directory: `tensorflow/contrib/lite/java/demo/app/src/main/assets/`
+To get a model, either:
 
-5. Build and run the app in Android Studio.
+* Download the quantized [Mobilenet TensorFlow Lite model](https://storage.googleapis.com/download.tensorflow.org/models/tflite/mobilenet_v1_224_android_quant_2017_11_08.zip)
+  and unzip and copy `mobilenet_quant_v1_224.tflite` to the assets directory:
+  `tensorflow/contrib/lite/java/demo/app/src/main/assets/`.
+* Or, download the floating point [Inception-v3 model](https://storage.googleapis.com/download.tensorflow.org/models/tflite/inception_v3_slim_2016_android_2017_11_10.zip)
+  and unzip and copy `inceptionv3_non_slim_2015.tflite` to the assets
+  directory. Change the chosen classifier in
+  [Camera2BasicFragment.java](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/lite/java/demo/app/src/main/java/com/example/android/tflitecamerademo/Camera2BasicFragment.java)<br>
+  from: `classifier = new ImageClassifierQuantizedMobileNet(getActivity());`<br>
+  to: `classifier = new ImageClassifierFloatInception(getActivity());`.
 
-You'll have to grant permissions for the app to use the device's camera. Point
-the camera at various objects and enjoy seeing how the model classifies things!
+Now you can build and run the demo app.
+
+
+## Build TensorFlow Lite and the demo app from source
+
+### Clone the TensorFlow repo
+
+```sh
+git clone https://github.com/tensorflow/tensorflow
+```
+
+### Install Bazel
+
+If `bazel` is not installed on your system, see
+[Installing Bazel](https://bazel.build/versions/master/docs/install.html).
+
+Note: Bazel does not currently support Android builds on Windows. Windows users
+should download the
+[prebuilt binary](https://storage.googleapis.com/download.tensorflow.org/deps/tflite/TfLiteCameraDemo.apk).
+
+### Install Android NDK and SDK
+
+The Android NDK is required to build the native (C/C++) TensorFlow Lite code. The
+current recommended version is *14b* and can be found on the
+[NDK Archives](https://developer.android.com/ndk/downloads/older_releases.html#ndk-14b-downloads)
+page.
+
+The Android SDK and build tools can be
+[downloaded separately](https://developer.android.com/tools/revisions/build-tools.html)
+or used as part of
+[Android Studio](https://developer.android.com/studio/index.html). To build the
+TensorFlow Lite Android demo, build tools require API >= 23 (but it will run on
+devices with API >= 21).
+
+In the root of the TensorFlow repository, update the `WORKSPACE` file with the
+`api_level` and location of the SDK and NDK. If you installed it with
+Android Studio, the SDK path can be found in the SDK manager. The default NDK
+path is:`{SDK path}/ndk-bundle.` For example:
+
+```
+android_sdk_repository (
+    name = "androidsdk",
+    api_level = 23,
+    build_tools_version = "23.0.2",
+    path = "/home/xxxx/android-sdk-linux/",
+)
+
+android_ndk_repository(
+    name = "androidndk",
+    path = "/home/xxxx/android-ndk-r10e/",
+    api_level = 19,
+)
+```
+
+Some additional details are available on the
+[TF Lite Android App page](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/lite/java/demo/README.md).
+
+### Build the source code
+
+To build the demo app, run `bazel`:
+
+```
+bazel build --cxxopt=--std=c++11 //tensorflow/contrib/lite/java/demo/app/src/main:TfLiteCameraDemo
+```
+
+Caution: Because of an bazel bug, we only support building the Android demo app
+within a Python 2 environment.
+
+
+## About the demo
+
+The demo app is resizing each camera image frame (224 width * 224 height) to
+match the quantized MobileNets model (299 * 299 for Inception-v3). The resized
+image is converted—row by row—into a
+[ByteBuffer](https://developer.android.com/reference/java/nio/ByteBuffer.html).
+Its size is  1 * 224 * 224 * 3 bytes, where 1 is the number of images in a batch.
+224 * 224 (299 * 299) is the width and height of the image. 3 bytes represents
+the 3 colors of a pixel.
+
+This demo uses the TensorFlow Lite Java inference API
+for models which take a single input and provide a single output. This outputs a
+two-dimensional array, with the first dimension being the category index and the
+second dimension being the confidence of classification. Both models have 1001
+unique categories and the app sorts the probabilities of all the categories and
+displays the top three. The model file must be downloaded and bundled within the
+assets directory of the app.
diff --git a/mobile/tflite/demo_ios.md b/mobile/tflite/demo_ios.md
index 3ee9b1c..3be21da 100644
--- a/mobile/tflite/demo_ios.md
+++ b/mobile/tflite/demo_ios.md
@@ -1,4 +1,4 @@
-# TensorFlow Lite Demo for iOS
+# iOS Demo App
 
 The TensorFlow Lite demo is a camera app that continuously classifies whatever
 it sees from your device's back camera, using a quantized MobileNet model. These
diff --git a/mobile/tflite/devguide.md b/mobile/tflite/devguide.md
new file mode 100644
index 0000000..4133bc1
--- /dev/null
+++ b/mobile/tflite/devguide.md
@@ -0,0 +1,231 @@
+# Developer Guide
+
+Using a TensorFlow Lite model in your mobile app requires multiple
+considerations: you must choose a pre-trained or custom model, convert the model
+to a TensorFLow Lite format, and finally, integrate the model in your app.
+
+## 1. Choose a model
+
+Depending on the use case, you can choose one of the popular open-sourced models,
+such as *InceptionV3* or *MobileNets*, and re-train these models with a custom
+data set or even build your own custom model.
+
+### Use a pre-trained model
+
+[MobileNets](https://research.googleblog.com/2017/06/mobilenets-open-source-models-for.html)
+is a family of mobile-first computer vision models for TensorFlow designed to
+effectively maximize accuracy, while taking into consideration the restricted
+resources for on-device or embedded applications. MobileNets are small,
+low-latency, low-power models parameterized to meet the resource constraints for
+a variety of uses. They can be used for classification, detection, embeddings, and
+segmentation—similar to other popular large scale models, such as
+[Inception](https://arxiv.org/pdf/1602.07261.pdf). Google provides 16 pre-trained
+[ImageNet](http://www.image-net.org/challenges/LSVRC/) classification checkpoints
+for MobileNets that can be used in mobile projects of all sizes.
+
+[Inception-v3](https://arxiv.org/abs/1512.00567) is an image recognition model
+that achieves fairly high accuracy recognizing general objects with 1000 classes,
+for example, "Zebra", "Dalmatian", and "Dishwasher". The model extracts general
+features from input images using a convolutional neural network and classifies
+them based on those features with fully-connected and softmax layers.
+
+[On Device Smart Reply](https://research.googleblog.com/2017/02/on-device-machine-intelligence.html)
+is an on-device model that provides one-touch replies for incoming text messages
+by suggesting contextually relevant messages. The model is built specifically for
+memory constrained devices, such as watches and phones, and has been successfully
+used in Smart Replies on Android Wear. Currently, this model is Android-specific.
+
+These pre-trained models are [available for download](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/lite/g3doc/models.md)
+
+### Re-train Inception-V3 or MobileNet for a custom data set
+
+These pre-trained models were trained on the *ImageNet* data set which contains
+1000 predefined classes. If these classes are not sufficient for your use case,
+the model will need to be re-trained. This technique is called
+*transfer learning* and starts with a model that has been already trained on a
+problem, then retrains the model on a similar problem. Deep learning from
+scratch can take days, but transfer learning is fairly quick. In order to do
+this, you need to generate a custom data set labeled with the relevant classes.
+
+The [TensorFlow for Poets](https://codelabs.developers.google.com/codelabs/tensorflow-for-poets/)
+codelab walks through the re-training process step-by-step. The code supports
+both floating point and quantized inference.
+
+### Train a custom model
+
+A developer may choose to train a custom model using Tensorflow (see the
+@{$tutorials} for examples of building and training models). If you have already
+written a model, the first step is to export this to a @{tf.GraphDef} file. This
+is required because some formats do not store the model structure outside the
+code, and we must communicate with other parts of the framework. See
+[Exporting the Inference Graph](https://github.com/tensorflow/models/blob/master/research/slim/README.md)
+to create .pb file for the custom model.
+
+TensorFlow Lite currently supports a subset of TensorFlow operators. Refer to the
+[TensorFlow Lite & TensorFlow Compatibility Guide](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/lite/g3doc/tf_ops_compatibility.md)
+for supported operators and their usage. This set of operators will continue to
+grow in future Tensorflow Lite releases.
+
+
+## 2. Convert the model format
+
+The model generated (or downloaded) in the previous step is a *standard*
+Tensorflow model and you should now have a .pb or .pbtxt @{tf.GraphDef} file.
+Models generated with transfer learning (re-training) or custom models must be
+converted—but, we must first freeze the graph to convert the model to the
+Tensorflow Lite format. This process uses several model formats:
+
+* @{tf.GraphDef} (.pb) —A protobuf that represents the TensorFlow training or
+  computation graph. It contains operators, tensors, and variables definitions.
+* *CheckPoint* (.ckpt) —Serialized variables from a TensorFlow graph. Since this
+  does not contain a graph structure, it cannot be interpreted by itself.
+* `FrozenGraphDef` —A subclass of `GraphDef` that does not contain
+  variables. A `GraphDef` can be converted to a `FrozenGraphDef` by taking a
+  CheckPoint and a `GraphDef`, and converting each variable into a constant
+  using the value retrieved from the CheckPoint.
+* `SavedModel` —A `GraphDef` and CheckPoint with a signature that labels
+  input and output arguments to a model. A `GraphDef` and CheckPoint can be
+  extracted from a `SavedModel`.
+* *TensorFlow Lite model* (.tflite) —A serialized
+  [FlatBuffer](https://google.github.io/flatbuffers/) that contains TensorFlow
+  Lite operators and tensors for the TensorFlow Lite interpreter, similar to a
+  `FrozenGraphDef`.
+
+### Freeze Graph
+
+To use the `GraphDef` .pb file with TensorFlow Lite, you must have checkpoints
+that contain trained weight parameters. The .pb file only contains the structure
+of the graph. The process of merging the checkpoint values with the graph
+structure is called *freezing the graph*.
+
+You should have a checkpoints folder or download them for a pre-trained model
+(for example,
+[MobileNets](https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet_v1.md)).
+
+To freeze the graph, use the following command (changing the arguments):
+
+```
+freeze_graph --input_graph=/tmp/mobilenet_v1_224.pb \
+  --input_checkpoint=/tmp/checkpoints/mobilenet-10202.ckpt \
+  --input_binary=true \
+  --output_graph=/tmp/frozen_mobilenet_v1_224.pb \
+  --output_node_names=MobileNetV1/Predictions/Reshape_1
+```
+
+The `input_binary` flag must be enabled so the protobuf is read and written in
+a binary format. Set the `input_graph` and `input_checkpoint` files.
+
+The `output_node_names` may not be obvious outside of the code that built the
+model. The easiest way to find them is to visualize the graph, either with
+[TensorBoard](https://codelabs.developers.google.com/codelabs/tensorflow-for-poets-2/#3)
+or `graphviz`.
+
+The frozen `GraphDef` is now ready for conversion to the `FlatBuffer` format
+(.tflite) for use on Android or iOS devices. For Android, the Tensorflow
+Optimizing Converter tool supports both float and quantized models. To convert
+the frozen `GraphDef` to the .tflite format:
+
+```
+toco --input_file=$(pwd)/mobilenet_v1_1.0_224/frozen_graph.pb \
+  --input_format=TENSORFLOW_GRAPHDEF \
+  --output_format=TFLITE \
+  --output_file=/tmp/mobilenet_v1_1.0_224.tflite \
+  --inference_type=FLOAT \
+  --input_type=FLOAT \
+  --input_arrays=input \
+  --output_arrays=MobilenetV1/Predictions/Reshape_1 \
+  --input_shapes=1,224,224,3
+```
+
+The `input_file` argument should reference the frozen `GraphDef` file
+containing the model architecture. The [frozen_graph.pb](https://storage.googleapis.com/download.tensorflow.org/models/mobilenet_v1_1.0_224_frozen.tgz)
+file used here is available for download. `output_file` is where the TensorFlow
+Lite model will get generated. The `input_type` and `inference_type`
+arguments should be set to `FLOAT`, unless converting a
+@{$performance/quantization$quantized model}. Setting the `input_array`,
+`output_array`, and `input_shape` arguments are not as straightforward. The
+easiest way to find these values is to explore the graph using Tensorboard. Reuse
+the arguments for specifying the output nodes for inference in the
+`freeze_graph` step.
+
+It is also possible to use the Tensorflow Optimizing Converter with protobufs
+from either Python or from the command line (see the 
+[toco_from_protos.py](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/lite/toco/python/toco_from_protos.py)
+example). This allows you to integrate the conversion step into the model design
+workflow, ensuring the model is easily convertible to a mobile inference graph.
+For example:
+
+```python
+import tensorflow as tf
+
+img = tf.placeholder(name="img", dtype=tf.float32, shape=(1, 64, 64, 3))
+val = img + tf.constant([1., 2., 3.]) + tf.constant([1., 4., 4.])
+out = tf.identity(val, name="out")
+
+with tf.Session() as sess:
+  tflite_model = tf.contrib.lite.toco_convert(sess.graph_def, [img], [out])
+  open("converteds_model.tflite", "wb").write(tflite_model)
+```
+
+For usage, see the Tensorflow Optimizing Converter
+[command-line examples](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/lite/toco/g3doc/cmdline_examples.md).
+
+Refer to the
+[Ops compatibility guide](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/lite/g3doc/tf_ops_compatibility.md)
+for troubleshooting help, and if that doesn't help, please
+[file an issue](https://github.com/tensorflow/tensorflow/issues).
+
+The [development repo](https://github.com/tensorflow/tensorflow) contains a tool
+to visualize TensorFlow Lite models after conversion. To build the
+[visualize.py](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/lite/tools/visualize.py)
+tool:
+
+```sh
+bazel run tensorflow/contrib/lite/tools:visualize -- model.tflite model_viz.html
+```
+
+This generates an interactive HTML page listing subgraphs, operations, and a
+graph visualization.
+
+
+## 3. Use the TensorFlow Lite model for inference in a mobile app
+
+After completing the prior steps, you should now have a `.tflite` model file.
+
+### Android
+
+Since Android apps are written in Java and the core TensorFlow library is in C++,
+a JNI library is provided as an interface. This is only meant for inference—it
+provides the ability to load a graph, set up inputs, and run the model to
+calculate outputs.
+
+The open source Android demo app uses the JNI interface and is available
+[on GitHub](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/lite/java/demo/app).
+You can also download a
+[prebuilt APK](http://download.tensorflow.org/deps/tflite/TfLiteCameraDemo.apk).
+See the @{$tflite/demo_android} guide for details.
+
+The @{$mobile/android_build} guide has instructions for installing TensorFlow on
+Android and setting up `bazel` and Android Studio.
+
+### iOS
+
+To integrate a TensorFlow model in an iOS app, see the
+[TensorFlow Lite for iOS](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/lite/g3doc/ios.md)
+guide and @{$tflite/demo_ios} guide.
+
+#### Core ML support
+
+Core ML is a machine learning framework used in Apple products. In addition to
+using Tensorflow Lite models directly in your applications, you can convert
+trained Tensorflow models to the
+[CoreML](https://developer.apple.com/machine-learning/) format for use on Apple
+devices. To use the converter, refer to the
+[Tensorflow-CoreML converter documentation](https://github.com/tf-coreml/tf-coreml).
+
+### Raspberry Pi
+
+Compile Tensorflow Lite for a Raspberry Pi by following the
+[RPi build instructions](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/lite/g3doc/rpi.md)
+This compiles a static library file (`.a`) used to build your app. There are
+plans for Python bindings and a demo app.
diff --git a/mobile/tflite/index.md b/mobile/tflite/index.md
index beb2479..11f11ea 100644
--- a/mobile/tflite/index.md
+++ b/mobile/tflite/index.md
@@ -155,7 +155,9 @@ retraining for both floating point and quantized inference.
 
 The following diagram shows the architectural design of TensorFlow Lite:
 
-![tensorflow lite architecture](https://www.tensorflow.org/images/tflite-architecture.jpg)
+<img src="http://github.com/images/tflite-architecture.jpg"
+     alt="TensorFlow Lite architecture diagram"
+     style="max-width:600px;">
 
 Starting with a trained TensorFlow model on disk, you'll convert that model to
 the TensorFlow Lite file format (`.tflite`) using the TensorFlow Lite
diff --git a/performance/leftnav_files b/performance/leftnav_files
index d11a7e5..1f894c3 100644
--- a/performance/leftnav_files
+++ b/performance/leftnav_files
@@ -1,3 +1,4 @@
+index.md
 performance_guide.md
 datasets_performance.md
 performance_models.md
diff --git a/performance/performance_guide.md b/performance/performance_guide.md
index cd47fc2..580a899 100644
--- a/performance/performance_guide.md
+++ b/performance/performance_guide.md
@@ -78,7 +78,7 @@ training CIFAR-10 illustrates the use of the `tf.data` API along with
 The `tf.data` API utilizes C++ multi-threading and has a much lower overhead
 than the Python-based `queue_runner` that is limited by Python's multi-threading
 performance. A detailed performance guide for the `tf.data` API can be found
-[here](#datasets_performance).
+[here](@{$datasets_performance}).
 
 While feeding data using a `feed_dict` offers a high level of flexibility, in
 general `feed_dict` does not provide a scalable solution. If only a single GPU
diff --git a/performance/xla/jit.md b/performance/xla/jit.md
index d4dc3e5..d9a979c 100644
--- a/performance/xla/jit.md
+++ b/performance/xla/jit.md
@@ -157,7 +157,7 @@ to fuse Ops is visible by starting at `hlo_graph_0.dot` and viewing each diagram
 in succession.
 
 To Render the .dot file into a png, install
-[GraphViz](http://www.graphviz.org/Download..php) and run:
+[GraphViz](https://www.graphviz.org/download/) and run:
 
 ```shell
 dot -Tpng hlo_graph_80.dot -o hlo_graph_80.png
diff --git a/performance/xla/operation_semantics.md b/performance/xla/operation_semantics.md
index 712d425..217ab59 100644
--- a/performance/xla/operation_semantics.md
+++ b/performance/xla/operation_semantics.md
@@ -241,13 +241,10 @@ See also
 
 Clamps an operand to within the range between a minimum and maximum value.
 
-<b> `Clamp(computation, args...)` </b>
+<b> `Clamp(min, operand, max)` </b>
 
 | Arguments     | Type                    | Semantics                        |
 | ------------- | ----------------------- | -------------------------------- |
-| `computation` | `Computation`           | computation of type `T_0, T_1,   |
-:               :                         : ..., T_N -> S` with N parameters :
-:               :                         : of arbitrary type                :
 | `min`         | `ComputationDataHandle` | array of type T                  |
 | `operand`     | `ComputationDataHandle` | array of type T                  |
 | `max`         | `ComputationDataHandle` | array of type T                  |
@@ -257,7 +254,7 @@ the range between the minimum and maximum, else returns the minimum value if the
 operand is below this range or the maximum value if the operand is above this
 range.  That is, `clamp(a, x, b) =  min(max(a, x), b)`.
 
-All three arrays must be the same shape. Alternately, as a restricted form of
+All three arrays must be the same shape. Alternatively, as a restricted form of
 [broadcasting](broadcasting.md), `min` and/or `max` can be a scalar of type `T`.
 
 Example with scalar `min` and `max`:
@@ -791,9 +788,7 @@ DynamicSlice extracts a sub-array from the input array at dynamic
 dimension: [start, start + size). The shape of `start_indices` must be rank ==
 1, with dimension size equal to the rank of `operand`.
 Note: handling of out-of-bounds slice indices (generated by incorrect runtime
-calculation of 'start_indices') is currently implementation-defined. Currently,
-slice indices are computed modulo input dimension sizes to prevent out-of-bound
-array accesses, but this behavior may change in future implementations.
+calculation of 'start_indices') is currently implementation-defined.
 
 <b> `DynamicSlice(operand, start_indices, size_indices)` </b>
 
@@ -850,9 +845,7 @@ is updated.
 The shape of `start_indices` must be rank == 1, with dimension size equal to
 the rank of `operand`.
 Note: handling of out-of-bounds slice indices (generated by incorrect runtime
-calculation of 'start_indices') is currently implementation-defined. Currently,
-slice indices are computed modulo update dimension sizes to prevent out-of-bound
-array accesses, but this behavior may change in future implementations.
+calculation of 'start_indices') is currently implementation-defined.
 
 <b> `DynamicUpdateSlice(operand, update, start_indices)` </b>
 
diff --git a/programmers_guide/debugger.md b/programmers_guide/debugger.md
index 5fb1c2d..f5a0eb0 100644
--- a/programmers_guide/debugger.md
+++ b/programmers_guide/debugger.md
@@ -4,29 +4,28 @@
 
 [TOC]
 
-TensorFlow debugger (**tfdbg**) is a specialized debugger for TensorFlow. It
-lets you view the internal structure and states of running TensorFlow graphs
-during training and inference, which is difficult to debug with general-purpose
-debuggers such as Python's `pdb` due to TensorFlow's computation-graph paradigm.
-
-> NOTE: TensorFlow debugger uses a
-> [curses](https://en.wikipedia.org/wiki/Curses_\(programming_library\))-based
-> text user interface. On Mac OS X, the `ncurses` library is required and can
-> be installed with `brew install homebrew/dupes/ncurses`. On Windows, curses
-> isn't as well supported, so a
-> [readline](https://en.wikipedia.org/wiki/GNU_Readline)-based interface can
-> be used with tfdbg by installing `pyreadline` with pip.
-> If you use Anaconda3, you can install it with a command
-> such as `"C:\Program Files\Anaconda3\Scripts\pip.exe" install pyreadline`.
-> Unofficial Windows curses packages can be downloaded
-> [here](https://www.lfd.uci.edu/~gohlke/pythonlibs/#curses), then subsequently
-> installed using `pip install <your_version>.whl`, however curses on Windows
-> may not work as reliably as curses on Linux or Mac.
-
-> NOTE: This guide focuses on the command-line interface (CLI) of tfdbg. For
-> guide on how to use the graphical user interface (GUI) of tfdbg, i.e., the
-> **TensorBoard Debugger Plugin**, please visit
-> [its README](https://github.com/tensorflow/tensorboard/blob/master/tensorboard/plugins/debugger/README.md).
+`tfdbg` is a specialized debugger for TensorFlow. It lets you view the internal
+structure and states of running TensorFlow graphs during training and inference,
+which is difficult to debug with general-purpose debuggers such as Python's `pdb`
+due to TensorFlow's computation-graph paradigm.
+
+This guide focuses on the command-line interface (CLI) of `tfdbg`. For guide on
+how to use the graphical user interface (GUI) of tfdbg, i.e., the
+**TensorBoard Debugger Plugin**, please visit
+[its README](https://github.com/tensorflow/tensorboard/blob/master/tensorboard/plugins/debugger/README.md).
+
+Note: The TensorFlow debugger uses a
+[curses](https://en.wikipedia.org/wiki/Curses_\(programming_library\))-based text
+user interface. On Mac OS X, the `ncurses` library is required and can be
+installed with `brew install homebrew/dupes/ncurses`. On Windows, curses isn't as
+well supported, so a [readline](https://en.wikipedia.org/wiki/GNU_Readline)-based
+interface can be used with tfdbg by installing `pyreadline` with `pip`. If you
+use Anaconda3, you can install it with a command such as
+`"C:\Program Files\Anaconda3\Scripts\pip.exe" install pyreadline`. Unofficial
+Windows curses packages can be downloaded
+[here](https://www.lfd.uci.edu/~gohlke/pythonlibs/#curses), then subsequently
+installed using `pip install <your_version>.whl`, however curses on Windows may
+not work as reliably as curses on Linux or Mac.
 
 This tutorial demonstrates how to use the **tfdbg** CLI to debug the appearance
 of [`nan`s](https://en.wikipedia.org/wiki/NaN)
@@ -155,6 +154,7 @@ Try the following commands at the `tfdbg>` prompt (referencing the code at
 | | `-n <name_pattern>` | List dumped tensors with names matching given regular-expression pattern. | `lt -n Softmax.*` |
 | | `-t <op_pattern>` | List dumped tensors with op types matching given regular-expression pattern. | `lt -t MatMul` |
 | | `-f <filter_name>` | List only the tensors that pass a registered tensor filter. | `lt -f has_inf_or_nan` |
+| | `-f <filter_name> -fenn <regex>` | List only the tensors that pass a registered tensor filter, excluding nodes with names matching the regular expression. | `lt -f has_inf_or_nan` `-fenn .*Sqrt.*` |
 | | `-s <sort_key>` | Sort the output by given `sort_key`, whose possible values are `timestamp` (default), `dump_size`, `op_type` and `tensor_name`. | `lt -s dump_size` |
 | | `-r` | Sort in reverse order. | `lt -r -s dump_size` |
 | **`pt`** | | **Print value of a dumped tensor.** | |
@@ -200,6 +200,7 @@ Try the following commands at the `tfdbg>` prompt (referencing the code at
 | | `-n` | Execute through the next `Session.run` without debugging, and drop to CLI right before the run after that. | `run -n` |
 | | `-t <T>` | Execute `Session.run` `T - 1` times without debugging, followed by a run with debugging. Then drop to CLI right after the debugged run. | `run -t 10` |
 | | `-f <filter_name>` | Continue executing `Session.run` until any intermediate tensor triggers the specified Tensor filter (causes the filter to return `True`). | `run -f has_inf_or_nan` |
+| | `-f <filter_name> -fenn <regex>` | Continue executing `Session.run` until any intermediate tensor whose node names doesn't match the regular expression triggers the specified Tensor filter (causes the filter to return `True`). | `run -f has_inf_or_nan -fenn .*Sqrt.*` |
 | | `--node_name_filter <pattern>` | Execute the next `Session.run`, watching only nodes with names matching the given regular-expression pattern. | `run --node_name_filter Softmax.*` |
 | | `--op_type_filter <pattern>` | Execute the next `Session.run`, watching only nodes with op types matching the given regular-expression pattern. | `run --op_type_filter Variable.*` |
 | | `--tensor_dtype_filter <pattern>` | Execute the next `Session.run`, dumping only Tensors with data types (`dtype`s) matching the given regular-expression pattern. | `run --tensor_dtype_filter int.*` |
@@ -459,7 +460,7 @@ accuracy_score = classifier.evaluate(x=test_set.data,
 
 
 [debug_tflearn_iris.py](https://www.tensorflow.org/code/tensorflow/python/debug/examples/debug_tflearn_iris.py),
-based on {$tflearn$tf-learn's iris tutorial}, contains a full example of how to
+based on [tf-learn's iris tutorial](https://www.tensorflow.org/versions/r1.2/get_started/tflearn), contains a full example of how to
 use the tfdbg with `Estimator`s. To run this example, do:
 
 ```none
@@ -746,15 +747,16 @@ There are three possible workarounds or solutions:
    to which tfdbg dumps the debug data. You can use it to let tfdbg dump the
    debug data on a disk with larger free space. For example:
 
-   ``` python
-   # For LocalCLIDebugWrapperSession
-   sess = tf_debug.LocalCLIDebugWrapperSession(dump_root="/with/lots/of/space")
+```python
+# For LocalCLIDebugWrapperSession
+sess = tf_debug.LocalCLIDebugWrapperSession(dump_root="/with/lots/of/space")
 
-   # For LocalCLIDebugHook
-   hooks = [tf_debug.LocalCLIDebugHook(dump_root="/with/lots/of/space")]
-   ```
+# For LocalCLIDebugHook
+hooks = [tf_debug.LocalCLIDebugHook(dump_root="/with/lots/of/space")]
+```
    Make sure that the directory pointed to by dump_root is empty or nonexistent.
-   tfdbg cleans up the dump directories before exiting.
+   `tfdbg` cleans up the dump directories before exiting.
+
 *  Reduce the batch size used during the runs.
 *  Use the filtering options of tfdbg's `run` command to watch only specific
    nodes in the graph. For example:
@@ -812,6 +814,20 @@ sess.run(b)
 the constant-folding would not occur and `tfdbg` should show the intermediate
 tensor dumps.
 
+
+**Q**: I am debugging a model that generates unwanted infinities or NaNs. But
+       there are some nodes in my model that are known to generate infinities
+       or NaNs in their output tensors even under completely normal conditions.
+       How can I skip those nodes during my `run -f has_inf_or_nan` actions?
+
+**A**: Use the `--filter_exclude_node_names` (`-fenn` for short) flag. For
+       example, if you known you have a node with name matching the regular
+       expression `.*Sqrt.*` that generates infinities or NaNs regardless
+       of whether the model is behaving correctly, you can exclude the nodes
+       from the infinity/NaN-finding runs with the command
+       `run -f has_inf_or_nan -fenn .*Sqrt.*`.
+
+
 **Q**: Is there a GUI for tfdbg?
 
 **A**: Yes, the **TensorBoard Debugger Plugin** is the GUI of tfdbg.
diff --git a/programmers_guide/eager.md b/programmers_guide/eager.md
new file mode 100644
index 0000000..595e6be
--- /dev/null
+++ b/programmers_guide/eager.md
@@ -0,0 +1,848 @@
+# Eager Execution
+
+TensorFlow's eager execution is an imperative programming environment that
+evaluates operations immediately, without building graphs: operations return
+concrete values instead of constructing a computational graph to run later. This
+makes it easy to get started with TensorFlow and debug models, and it
+reduces boilerplate as well. To follow along with this guide, run the code
+samples below in an interactive `python` interpreter.
+
+Eager execution is a flexible machine learning platform for research and
+experimentation, providing:
+
+* *An intuitive interface*—Structure your code naturally and use Python data
+  structures. Quickly iterate on small models and small data.
+* *Easier debugging*—Call ops directly to inspect running models and test
+  changes. Use standard Python debugging tools for immediate error reporting.
+* *Natural control flow*—Use Python control flow instead of graph control
+  flow, simplifying the specification of dynamic models.
+
+Eager execution supports most TensorFlow operations and GPU acceleration. For a
+collection of examples running in eager execution, see:
+[tensorflow/contrib/eager/python/examples](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/eager/python/examples).
+
+Note: Some models may experience increased overhead with eager execution
+enabled. Performance improvements are ongoing, but please
+[file a bug](https://github.com/tensorflow/tensorflow/issues) if you find a
+problem and share your benchmarks.
+
+## Setup and basic usage
+
+Upgrade to the latest version of TensorFlow:
+
+```
+$ pip install --upgrade tensorflow
+```
+
+To start eager execution, add `tf.enable_eager_execution()` to the beginning of
+the program or console session. Do not add this operation to other modules that
+the program calls.
+
+```py
+from __future__ import absolute_import, division, print_function
+
+import tensorflow as tf
+
+tf.enable_eager_execution()
+```
+
+Now you can run TensorFlow operations and the results will return immediately:
+
+```py
+tf.executing_eagerly()        # => True
+
+x = [[2.]]
+m = tf.matmul(x, x)
+print("hello, {}".format(m))  # => "hello, [[4.]]"
+```
+
+Enabling eager execution changes how TensorFlow operations behave—now they
+immediately evaluate and return their values to Python. `tf.Tensor` objects
+reference concrete values instead of symbolic handles to nodes in a computational
+graph. Since there isn't a computational graph to build and run later in a
+session, it's easy to inspect results using `print()` or a debugger. Evaluating,
+printing, and checking tensor values does not break the flow for computing
+gradients.
+
+Eager execution works nicely with [NumPy](http://www.numpy.org/). NumPy
+operations accept `tf.Tensor` arguments. TensorFlow
+[math operations](https://www.tensorflow.org/api_guides/python/math_ops) convert
+Python objects and NumPy arrays to `tf.Tensor` objects. The
+`tf.Tensor.numpy` method returns the object's value as a NumPy `ndarray`.
+
+```py
+a = tf.constant([[1, 2],
+                 [3, 4]])
+print(a)
+# => tf.Tensor([[1 2]
+#               [3 4]], shape=(2, 2), dtype=int32)
+
+# Broadcasting support
+b = tf.add(a, 1)
+print(b)
+# => tf.Tensor([[2 3]
+#               [4 5]], shape=(2, 2), dtype=int32)
+
+# Operator overloading is supported
+print(a * b)
+# => tf.Tensor([[ 2  6]
+#               [12 20]], shape=(2, 2), dtype=int32)
+
+# Use NumPy values
+import numpy as np
+
+c = np.multiply(a, b)
+print(c)
+# => [[ 2  6]
+#     [12 20]]
+
+# Obtain numpy value from a tensor:
+print(a.numpy())
+# => [[1 2]
+#     [3 4]]
+```
+
+The `tf.contrib.eager` module contains symbols available to both eager and graph execution
+environments and is useful for writing code to [work with graphs](#work_with_graphs):
+
+```py
+tfe = tf.contrib.eager
+```
+
+## Dynamic control flow
+
+A major benefit of eager execution is that all the functionality of the host
+language is available while your model is executing. So, for example,
+it is easy to write [fizzbuzz](https://en.wikipedia.org/wiki/Fizz_buzz):
+
+```py
+def fizzbuzz(max_num):
+  counter = tf.constant(0)
+  for num in range(max_num):
+    num = tf.constant(num)
+    if num % 3 == 0 and num % 5 == 0:
+      print('FizzBuzz')
+    elif num % 3 == 0:
+      print('Fizz')
+    elif num % 5 == 0:
+      print('Buzz')
+    else:
+      print(num)
+    counter += 1
+  return counter
+```
+
+This has conditionals that depend on tensor values and it prints these values
+at runtime.
+
+## Build a model
+
+Many machine learning models are represented by composing layers. When
+using TensorFlow with eager execution you can either write your own layers or
+use a layer provided in the `tf.keras.layers` package.
+
+While you can use any Python object to represent a layer,
+TensorFlow has `tf.keras.layers.Layer` as a convenient base class. Inherit from
+it to implement your own layer:
+
+```py
+class MySimpleLayer(tf.keras.layers.Layer):
+  def __init__(self, output_units):
+    self.output_units = output_units
+
+  def build(self, input):
+    # The build method gets called the first time your layer is used.
+    # Creating variables on build() allows you to make their shape depend
+    # on the input shape and hence remove the need for the user to specify
+    # full shapes. It is possible to create variables during __init__() if
+    # you already know their full shapes.
+    self.kernel = self.add_variable(
+      "kernel", [input.shape[-1], self.output_units])
+
+  def call(self, input):
+    # Override call() instead of __call__ so we can perform some bookkeeping.
+    return tf.matmul(input, self.kernel)
+```
+
+Use `tf.keras.layers.Dense` layer instead  of `MySimpleLayer` above as it has
+a superset of its functionality (it can also add a bias).
+
+When composing layers into models you can use `tf.keras.Sequential` to represent
+models which are a linear stack of layers. It is easy to use for basic models:
+
+```py
+model = tf.keras.Sequential([
+  tf.keras.layers.Dense(10, input_shape=(784,)),  # must declare input shape
+  tf.keras.layers.Dense(10)
+])
+```
+
+Alternatively, organize models in classes by inheriting from `tf.keras.Model`.
+This is a container for layers that is a layer itself, allowing `tf.keras.Model`
+objects to contain other `tf.keras.Model` objects.
+
+```py
+class MNISTModel(tf.keras.Model):
+  def __init__(self):
+    super(MNISTModel, self).__init__()
+    self.dense1 = tf.keras.layers.Dense(units=10)
+    self.dense2 = tf.keras.layers.Dense(units=10)
+
+  def call(self, input):
+    """Run the model."""
+    result = self.dense1(input)
+    result = self.dense2(result)
+    result = self.dense2(result)  # reuse variables from dense2 layer
+    return result
+
+model = MNISTModel()
+```
+
+It's not required to set an input shape for the `tf.keras.Model` class since
+the parameters are set the first time input is passed to the layer.
+
+`tf.keras.layers` classes create and contain their own model variables that
+are tied to the lifetime of their layer objects. To share layer variables, share
+their objects.
+
+
+## Eager training
+
+### Computing gradients
+
+[Automatic differentiation](https://en.wikipedia.org/wiki/Automatic_differentiation)
+is useful for implementing machine learning algorithms such as
+[backpropagation](https://en.wikipedia.org/wiki/Backpropagation) for training
+neural networks. During eager execution, use `tf.GradientTape` to trace
+operations for computing gradients later.
+
+`tf.GradientTape` is an opt-in feature to provide maximal performance when
+not tracing. Since different operations can occur during each call, all
+forward-pass operations get recorded to a "tape". To compute the gradient, play
+the tape backwards and then discard. A particular `tf.GradientTape` can only
+compute one gradient; subsequent calls throw a runtime error.
+
+```py
+w = tfe.Variable([[1.0]])
+with tf.GradientTape() as tape:
+  loss = w * w
+
+grad = tape.gradient(loss, [w])
+print(grad)  # => [tf.Tensor([[ 2.]], shape=(1, 1), dtype=float32)]
+```
+
+Here's an example of `tf.GradientTape` that records forward-pass operations
+to train a simple model:
+
+```py
+# A toy dataset of points around 3 * x + 2
+NUM_EXAMPLES = 1000
+training_inputs = tf.random_normal([NUM_EXAMPLES])
+noise = tf.random_normal([NUM_EXAMPLES])
+training_outputs = training_inputs * 3 + 2 + noise
+
+def prediction(input, weight, bias):
+  return input * weight + bias
+
+# A loss function using mean-squared error
+def loss(weights, biases):
+  error = prediction(training_inputs, weights, biases) - training_outputs
+  return tf.reduce_mean(tf.square(error))
+
+# Return the derivative of loss with respect to weight and bias
+def grad(weights, biases):
+  with tf.GradientTape() as tape:
+    loss_value = loss(weights, biases)
+  return tape.gradient(loss_value, [weights, biases])
+
+train_steps = 200
+learning_rate = 0.01
+# Start with arbitrary values for W and B on the same batch of data
+W = tfe.Variable(5.)
+B = tfe.Variable(10.)
+
+print("Initial loss: {:.3f}".format(loss(W, B)))
+
+for i in range(train_steps):
+  dW, dB = grad(W, B)
+  W.assign_sub(dW * learning_rate)
+  B.assign_sub(dB * learning_rate)
+  if i % 20 == 0:
+    print("Loss at step {:03d}: {:.3f}".format(i, loss(W, B)))
+
+print("Final loss: {:.3f}".format(loss(W, B)))
+print("W = {}, B = {}".format(W.numpy(), B.numpy()))
+```
+
+Output (exact numbers may vary):
+
+```
+Initial loss: 71.204
+Loss at step 000: 68.333
+Loss at step 020: 30.222
+Loss at step 040: 13.691
+Loss at step 060: 6.508
+Loss at step 080: 3.382
+Loss at step 100: 2.018
+Loss at step 120: 1.422
+Loss at step 140: 1.161
+Loss at step 160: 1.046
+Loss at step 180: 0.996
+Final loss: 0.974
+W = 3.01582956314, B = 2.1191945076
+```
+
+Replay the `tf.GradientTape` to compute the gradients and apply them in a
+training loop. This is demonstrated in an excerpt from the
+[mnist_eager.py](https://github.com/tensorflow/models/blob/master/official/mnist/mnist_eager.py)
+example:
+
+```py
+dataset = tf.data.Dataset.from_tensor_slices((data.train.images,
+                                              data.train.labels))
+...
+for (batch, (images, labels)) in enumerate(dataset):
+  ...
+  with tf.GradientTape() as tape:
+    logits = model(images, training=True)
+    loss_value = loss(logits, labels)
+  ...
+  grads = tape.gradient(loss_value, model.variables)
+  optimizer.apply_gradients(zip(grads, model.variables),
+                            global_step=tf.train.get_or_create_global_step())
+```
+
+
+The following example creates a multi-layer model that classifies the standard
+[MNIST handwritten digits](https://www.tensorflow.org/tutorials/layers). It
+demonstrates the optimizer and layer APIs to build trainable graphs in an eager
+execution environment.
+
+### Train a model
+
+Even without training, call the model and inspect the output in eager execution:
+
+```py
+# Create a tensor representing a blank image
+batch = tf.zeros([1, 1, 784])
+print(batch.shape)  # => (1, 1, 784)
+
+result = model(batch)
+# => tf.Tensor([[[ 0.  0., ..., 0.]]], shape=(1, 1, 10), dtype=float32)
+```
+
+This example uses the
+[dataset.py module](https://github.com/tensorflow/models/blob/master/official/mnist/dataset.py)
+from the
+[TensorFlow MNIST example](https://github.com/tensorflow/models/tree/master/official/mnist);
+download this file to your local directory. Run the following to download the
+MNIST data files to your working directory and prepare a `tf.data.Dataset`
+for training:
+
+```py
+import dataset  # download dataset.py file
+dataset_train = dataset.train('./datasets').shuffle(60000).repeat(4).batch(32)
+```
+
+To train a model, define a loss function to optimize and then calculate
+gradients. Use an optimizer to update the variables:
+
+```py
+def loss(model, x, y):
+  prediction = model(x)
+  return tf.losses.sparse_softmax_cross_entropy(labels=y, logits=prediction)
+
+def grad(model, inputs, targets):
+  with tf.GradientTape() as tape:
+    loss_value = loss(model, inputs, targets)
+  return tape.gradient(loss_value, model.variables)
+
+optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
+
+x, y = iter(dataset_train).next()
+print("Initial loss: {:.3f}".format(loss(model, x, y)))
+
+# Training loop
+for (i, (x, y)) in enumerate(dataset_train):
+  # Calculate derivatives of the input function with respect to its parameters.
+  grads = grad(model, x, y)
+  # Apply the gradient to the model
+  optimizer.apply_gradients(zip(grads, model.variables),
+                            global_step=tf.train.get_or_create_global_step())
+  if i % 200 == 0:
+    print("Loss at step {:04d}: {:.3f}".format(i, loss(model, x, y)))
+
+print("Final loss: {:.3f}".format(loss(model, x, y)))
+```
+
+Output (exact numbers may vary):
+
+```
+Initial loss: 2.674
+Loss at step 0000: 2.593
+Loss at step 0200: 2.143
+Loss at step 0400: 2.009
+Loss at step 0600: 2.103
+Loss at step 0800: 1.621
+Loss at step 1000: 1.695
+...
+Loss at step 6600: 0.602
+Loss at step 6800: 0.557
+Loss at step 7000: 0.499
+Loss at step 7200: 0.744
+Loss at step 7400: 0.681
+Final loss: 0.670
+```
+
+And for faster training, move the computation to a GPU:
+
+```py
+with tf.device("/gpu:0"):
+  for (i, (x, y)) in enumerate(dataset_train):
+    # minimize() is equivalent to the grad() and apply_gradients() calls.
+    optimizer.minimize(lambda: loss(model, x, y),
+                       global_step=tf.train.get_or_create_global_step())
+```
+
+### Variables and optimizers
+
+`tfe.Variable` objects store mutable `tf.Tensor` values accessed during
+training to make automatic differentiation easier. The parameters of a model can
+be encapsulated in classes as variables.
+
+Better encapsulate model parameters by using `tfe.Variable` with
+`tf.GradientTape`. For example, the automatic differentiation example above
+can be rewritten:
+
+```py
+class Model(tf.keras.Model):
+  def __init__(self):
+    super(Model, self).__init__()
+    self.W = tfe.Variable(5., name='weight')
+    self.B = tfe.Variable(10., name='bias')
+  def predict(self, inputs):
+    return inputs * self.W + self.B
+
+# A toy dataset of points around 3 * x + 2
+NUM_EXAMPLES = 2000
+training_inputs = tf.random_normal([NUM_EXAMPLES])
+noise = tf.random_normal([NUM_EXAMPLES])
+training_outputs = training_inputs * 3 + 2 + noise
+
+# The loss function to be optimized
+def loss(model, inputs, targets):
+  error = model.predict(inputs) - targets
+  return tf.reduce_mean(tf.square(error))
+
+def grad(model, inputs, targets):
+  with tf.GradientTape() as tape:
+    loss_value = loss(model, inputs, targets)
+  return tape.gradient(loss_value, [model.W, model.B])
+
+# Define:
+# 1. A model.
+# 2. Derivatives of a loss function with respect to model parameters.
+# 3. A strategy for updating the variables based on the derivatives.
+model = Model()
+optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
+
+print("Initial loss: {:.3f}".format(loss(model, training_inputs, training_outputs)))
+
+# Training loop
+for i in range(300):
+  grads = grad(model, training_inputs, training_outputs)
+  optimizer.apply_gradients(zip(grads, [model.W, model.B]),
+                            global_step=tf.train.get_or_create_global_step())
+  if i % 20 == 0:
+    print("Loss at step {:03d}: {:.3f}".format(i, loss(model, training_inputs, training_outputs)))
+
+print("Final loss: {:.3f}".format(loss(model, training_inputs, training_outputs)))
+print("W = {}, B = {}".format(model.W.numpy(), model.B.numpy()))
+```
+
+Output (exact numbers may vary):
+
+```
+Initial loss: 69.066
+Loss at step 000: 66.368
+Loss at step 020: 30.107
+Loss at step 040: 13.959
+Loss at step 060: 6.769
+Loss at step 080: 3.567
+Loss at step 100: 2.141
+Loss at step 120: 1.506
+Loss at step 140: 1.223
+Loss at step 160: 1.097
+Loss at step 180: 1.041
+Loss at step 200: 1.016
+Loss at step 220: 1.005
+Loss at step 240: 1.000
+Loss at step 260: 0.998
+Loss at step 280: 0.997
+Final loss: 0.996
+W = 2.99431324005, B = 2.02129220963
+```
+
+## Use objects for state during eager execution
+
+With graph execution, program state (such as the variables) is stored in global
+collections and their lifetime is managed by the `tf.Session` object. In
+contrast, during eager execution the lifetime of state objects is determined by
+the lifetime of their corresponding Python object.
+
+### Variables are objects
+
+During eager execution, variables persist until the last reference to the object
+is removed, and is then deleted.
+
+```py
+with tf.device("gpu:0"):
+  v = tfe.Variable(tf.random_normal([1000, 1000]))
+  v = None  # v no longer takes up GPU memory
+```
+
+### Object-based saving
+
+`tfe.Checkpoint` can save and restore `tfe.Variable`s to and from
+checkpoints:
+
+```py
+x = tfe.Variable(10.)
+
+checkpoint = tfe.Checkpoint(x=x)  # save as "x"
+
+x.assign(2.)   # Assign a new value to the variables and save.
+save_path = checkpoint.save('./ckpt/')
+
+x.assign(11.)  # Change the variable after saving.
+
+# Restore values from the checkpoint
+checkpoint.restore(save_path)
+
+print(x)  # => 2.0
+```
+
+To save and load models, `tfe.Checkpoint` stores the internal state of objects,
+without requiring hidden variables. To record the state of a `model`,
+an `optimizer`, and a global step, pass them to a `tfe.Checkpoint`:
+
+```py
+model = MyModel()
+optimizer = tf.train.AdamOptimizer(learning_rate=0.001)
+checkpoint_dir = ‘/path/to/model_dir’
+checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt")
+root = tfe.Checkpoint(optimizer=optimizer,
+                      model=model,
+                      optimizer_step=tf.train.get_or_create_global_step())
+
+root.save(file_prefix=checkpoint_prefix)
+# or
+root.restore(tf.train.latest_checkpoint(checkpoint_dir))
+```
+
+### Object-oriented metrics
+
+`tfe.metrics` are stored as objects. Update a metric by passing the new data to
+the callable, and retrieve the result using the `tfe.metrics.result` method,
+for example:
+
+```py
+m = tfe.metrics.Mean("loss")
+m(0)
+m(5)
+m.result()  # => 2.5
+m([8, 9])
+m.result()  # => 5.5
+```
+
+#### Summaries and TensorBoard
+
+@{$summaries_and_tensorboard$TensorBoard} is a visualization tool for
+understanding, debugging and optimizing the model training process. It uses
+summary events that are written while executing the program.
+
+`tf.contrib.summary` is compatible with both eager and graph execution
+environments. Summary operations, such as `tf.contrib.summary.scalar`, are
+inserted during model construction. For example, to record summaries once every
+100 global steps:
+
+```py
+writer = tf.contrib.summary.create_file_writer(logdir)
+global_step=tf.train.get_or_create_global_step()  # return global step var
+
+writer.set_as_default()
+
+for _ in range(iterations):
+  global_step.assign_add(1)
+  # Must include a record_summaries method
+  with tf.contrib.summary.record_summaries_every_n_global_steps(100):
+    # your model code goes here
+    tf.contrib.summary.scalar('loss', loss)
+     ...
+```
+
+## Advanced automatic differentiation topics
+
+### Dynamic models
+
+`tf.GradientTape` can also be used in dynamic models. This example for a
+[backtracking line search](https://wikipedia.org/wiki/Backtracking_line_search)
+algorithm looks like normal NumPy code, except there are gradients and is
+differentiable, despite the complex control flow:
+
+```py
+def line_search_step(fn, init_x, rate=1.0):
+  with tf.GradientTape() as tape:
+    # Variables are automatically recorded, but manually watch a tensor
+    tape.watch(init_x)
+    value = fn(init_x)
+  grad, = tape.gradient(value, [init_x])
+  grad_norm = tf.reduce_sum(grad * grad)
+  init_value = value
+  while value > init_value - rate * grad_norm:
+    x = init_x - rate * grad
+    value = fn(x)
+    rate /= 2.0
+  return x, value
+```
+
+### Additional functions to compute gradients
+
+`tf.GradientTape` is a powerful interface for computing gradients, but there
+is another [Autograd](https://github.com/HIPS/autograd)-style API available for
+automatic differentiation. These functions are useful if writing math code with
+only tensors and gradient functions, and without `tfe.Variables`:
+
+* `tfe.gradients_function` —Returns a function that computes the derivatives
+  of its input function parameter with respect to its arguments. The input
+  function parameter must return a scalar value. When the returned function is
+  invoked, it returns a list of `tf.Tensor` objects: one element for each
+  argument of the input function. Since anything of interest must be passed as a
+  function parameter, this becomes unwieldy if there's a dependency on many
+  trainable parameters.
+* `tfe.value_and_gradients_function` —Similar to
+  `tfe.gradients_function`, but when the returned function is invoked, it
+  returns the value from the input function in addition to the list of
+  derivatives of the input function with respect to its arguments.
+
+In the following example, `tfe.gradients_function` takes the `square`
+function as an argument and returns a function that computes the partial
+derivatives of `square` with respect to its inputs. To calculate the derivative
+of `square` at `3`, `grad(3.0)` returns `6`.
+
+```py
+def square(x):
+  return tf.multiply(x, x)
+
+grad = tfe.gradients_function(square)
+
+square(3.)  # => 9.0
+grad(3.)    # => [6.0]
+
+# The second-order derivative of square:
+gradgrad = tfe.gradients_function(lambda x: grad(x)[0])
+gradgrad(3.)  # => [2.0]
+
+# The third-order derivative is None:
+gradgradgrad = tfe.gradients_function(lambda x: gradgrad(x)[0])
+gradgradgrad(3.)  # => [None]
+
+
+# With flow control:
+def abs(x):
+  return x if x > 0. else -x
+
+grad = tfe.gradients_function(abs)
+
+grad(3.)   # => [1.0]
+grad(-3.)  # => [-1.0]
+```
+
+### Custom gradients
+
+Custom gradients are an easy way to override gradients in eager and graph
+execution. Within the forward function, define the gradient with respect to the
+inputs, outputs, or intermediate results. For example, here's an easy way to clip
+the norm of the gradients in the backward pass:
+
+```py
+@tf.custom_gradient
+def clip_gradient_by_norm(x, norm):
+  y = tf.identity(x)
+  def grad_fn(dresult):
+    return [tf.clip_by_norm(dresult, norm), None]
+  return y, grad_fn
+```
+
+Custom gradients are commonly used to provide a numerically stable gradient for a
+sequence of operations:
+
+```py
+def log1pexp(x):
+  return tf.log(1 + tf.exp(x))
+grad_log1pexp = tfe.gradients_function(log1pexp)
+
+# The gradient computation works fine at x = 0.
+grad_log1pexp(0.)  # => [0.5]
+
+# However, x = 100 fails because of numerical instability.
+grad_log1pexp(100.)  # => [nan]
+```
+
+Here, the `log1pexp` function can be analytically simplified with a custom
+gradient. The implementation below reuses the value for `tf.exp(x)` that is
+computed during the forward pass—making it more efficient by eliminating
+redundant calculations:
+
+```py
+@tf.custom_gradient
+def log1pexp(x):
+  e = tf.exp(x)
+  def grad(dy):
+    return dy * (1 - 1 / (1 + e))
+  return tf.log(1 + e), grad
+
+grad_log1pexp = tfe.gradients_function(log1pexp)
+
+# As before, the gradient computation works fine at x = 0.
+grad_log1pexp(0.)  # => [0.5]
+
+# And the gradient computation also works at x = 100.
+grad_log1pexp(100.)  # => [1.0]
+```
+
+## Performance
+
+Computation is automatically offloaded to GPUs during eager execution. If you
+want control over where a computation runs you can enclose it in a
+`tf.device('/gpu:0')` block (or the CPU equivalent):
+
+```py
+import time
+
+def measure(x, steps):
+  # TensorFlow initializes a GPU the first time it's used, exclude from timing.
+  tf.matmul(x, x)
+  start = time.time()
+  for i in range(steps):
+    x = tf.matmul(x, x)
+    _ = x.numpy()  # Make sure to execute op and not just enqueue it
+  end = time.time()
+  return end - start
+
+shape = (1000, 1000)
+steps = 200
+print("Time to multiply a {} matrix by itself {} times:".format(shape, steps))
+
+# Run on CPU:
+with tf.device("/cpu:0"):
+  print("CPU: {} secs".format(measure(tf.random_normal(shape), steps)))
+
+# Run on GPU, if available:
+if tfe.num_gpus() > 0:
+  with tf.device("/gpu:0"):
+    print("GPU: {} secs".format(measure(tf.random_normal(shape), steps)))
+else:
+  print("GPU: not found")
+```
+
+Output (exact numbers depend on hardware):
+
+```
+Time to multiply a (1000, 1000) matrix by itself 200 times:
+CPU: 4.614904403686523 secs
+GPU: 0.5581181049346924 secs
+```
+
+A `tf.Tensor` object can be copied to a different device to execute its
+operations:
+
+```py
+x = tf.random_normal([10, 10])
+
+x_gpu0 = x.gpu()
+x_cpu = x.cpu()
+
+_ = tf.matmul(x_cpu, x_cpu)    # Runs on CPU
+_ = tf.matmul(x_gpu0, x_gpu0)  # Runs on GPU:0
+
+if tfe.num_gpus() > 1:
+  x_gpu1 = x.gpu(1)
+  _ = tf.matmul(x_gpu1, x_gpu1)  # Runs on GPU:1
+```
+
+### Benchmarks
+
+For compute-heavy models, such as
+[ResNet50](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/eager/python/examples/resnet50)
+training on a GPU, eager execution performance is comparable to graph execution.
+But this gap grows larger for models with less computation and there is work to
+be done for optimizing hot code paths for models with lots of small operations.
+
+
+## Work with graphs
+
+While eager execution makes development and debugging more interactive,
+TensorFlow graph execution has advantages for distributed training, performance
+optimizations, and production deployment. However, writing graph code can feel
+different than writing regular Python code and more difficult to debug.
+
+For building and training graph-constructed models, the Python program first
+builds a graph representing the computation, then invokes `Session.run` to send
+the graph for execution on the C++-based runtime.  This provides:
+
+* Automatic differentiation using static autodiff.
+* Simple deployment to a platform independent server.
+* Graph-based optimizations (common subexpression elimination, constant-folding, etc.).
+* Compilation and kernel fusion.
+* Automatic distribution and replication (placing nodes on the distributed system).
+
+Deploying code written for eager execution is more difficult: either generate a
+graph from the model, or run the Python runtime and code directly on the server.
+
+### Write compatible code
+
+The same code written for eager execution will also build a graph during graph
+execution. Do this by simply running the same code in a new Python session where
+eager execution is not enabled.
+
+Most TensorFlow operations work during eager execution, but there are some things
+to keep in mind:
+
+* Use `tf.data` for input processing instead of queues. It's faster and easier.
+* Use object-oriented layer APIs—like `tf.keras.layers` and
+  `tf.keras.Model`—since they have explicit storage for variables.
+* Most model code works the same during eager and graph execution, but there are
+  exceptions. (For example, dynamic models using Python control flow to change the
+  computation based on inputs.)
+* Once eager execution is enabled with `tf.enable_eager_execution`, it
+  cannot be turned off. Start a new Python session to return to graph execution.
+
+It's best to write code for both eager execution *and* graph execution. This
+gives you eager's interactive experimentation and debuggability with the
+distributed performance benefits of graph execution.
+
+Write, debug, and iterate in eager execution, then import the model graph for
+production deployment. Use `tfe.Checkpoint` to save and restore model
+variables, this allows movement between eager and graph execution environments.
+See the examples in:
+[tensorflow/contrib/eager/python/examples](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/eager/python/examples).
+
+### Use eager execution in a graph environment
+
+Selectively enable eager execution in a TensorFlow graph environment using
+`tfe.py_func`. This is used when `tf.enable_eager_execution()` has *not*
+been called.
+
+```py
+def my_py_func(x):
+  x = tf.matmul(x, x)  # You can use tf ops
+  print(x)  # but it's eager!
+  return x
+
+with tf.Session() as sess:
+  x = tf.placeholder(dtype=tf.float32)
+  # Call eager function in graph!
+  pf = tfe.py_func(my_py_func, [x], tf.float32)
+  sess.run(pf, feed_dict={x: [[2.0]]})  # [[4.0]]
+```
diff --git a/programmers_guide/embedding.md b/programmers_guide/embedding.md
index e8027fc..d5703e0 100644
--- a/programmers_guide/embedding.md
+++ b/programmers_guide/embedding.md
@@ -7,6 +7,9 @@ with the TensorBoard Embedding Projector
 newcomers to machine learning or TensorFlow, and the Embedding Projector how-to
 is for users at all levels.
 
+An alternative tutorial on these concepts is available in the
+[Embeddings section of Machine Learning Crash Course](https://developers.google.com/machine-learning/crash-course/embeddings/video-lecture).
+
 [TOC]
 
 An **embedding** is a mapping from discrete objects, such as words, to vectors
diff --git a/programmers_guide/faq.md b/programmers_guide/faq.md
index 1548d43..392ac6f 100644
--- a/programmers_guide/faq.md
+++ b/programmers_guide/faq.md
@@ -159,7 +159,7 @@ available. These operations allow you to build sophisticated
 @{$reading_data$input pipelines}, at the cost of making the
 TensorFlow computation somewhat more complicated. See the how-to documentation
 for
-@{$reading_data#creating-threads-to-prefetch-using-queuerunner-objects$using `QueueRunner` objects to drive queues and readers}
+@{$reading_data#creating_threads_to_prefetch_using_queuerunner_objects$using `QueueRunner` objects to drive queues and readers}
 for more information on how to use them.
 
 ## Variables
@@ -272,7 +272,7 @@ Prefer predefined TensorFlow operations such as @{tf.decode_raw},
 
 If your data is not easily parsable with the built-in TensorFlow operations,
 consider converting it, offline, to a format that is easily parsable, such
-as ${tf.python_io.TFRecordWriter$`TFRecord`} format.
+as @{tf.python_io.TFRecordWriter$`TFRecord`} format.
 
 The more efficient method to customize the parsing behavior is to
 @{$adding_an_op$add a new op written in C++} that parses your
diff --git a/programmers_guide/index.md b/programmers_guide/index.md
index e8c2fa6..017db0e 100644
--- a/programmers_guide/index.md
+++ b/programmers_guide/index.md
@@ -5,6 +5,7 @@ works. The units are as follows:
 
 ## High Level APIs
 
+  * @{$programmers_guide/eager}, which is the easiest way to use tensorflow.
   * @{$programmers_guide/estimators}, which introduces a high-level
     TensorFlow API that greatly simplifies ML programming.
   * @{$programmers_guide/datasets}, which explains how to
diff --git a/programmers_guide/leftnav_files b/programmers_guide/leftnav_files
index 3fe4cb2..7ac63bf 100644
--- a/programmers_guide/leftnav_files
+++ b/programmers_guide/leftnav_files
@@ -1,8 +1,9 @@
 index.md
 
 ### High Level APIs
-estimators.md
+eager.md
 datasets.md
+estimators.md
 
 ### Low Level APIs
 low_level_intro.md
diff --git a/programmers_guide/saved_model.md b/programmers_guide/saved_model.md
index 5dfe6ef..55ee42d 100644
--- a/programmers_guide/saved_model.md
+++ b/programmers_guide/saved_model.md
@@ -3,7 +3,7 @@
 The @{tf.train.Saver} class provides methods to save and restore models. The
 @{tf.saved_model.simple_save} function is an easy way to build a
 @{tf.saved_model$saved model} suitable for serving.
-[Estimators](/programmers_guide/estimators) automatically save and restore
+[Estimators](@{$programmers_guide/estimators}) automatically save and restore
 variables in the `model_dir`.
 
 ## Save and restore variables
@@ -256,18 +256,53 @@ with tf.Session(graph=tf.Graph()) as sess:
   builder.add_meta_graph_and_variables(sess,
                                        [tag_constants.TRAINING],
                                        signature_def_map=foo_signatures,
-                                       assets_collection=foo_assets)
+                                       assets_collection=foo_assets,
+                                       strip_default_attrs=True)
 ...
 # Add a second MetaGraphDef for inference.
 with tf.Session(graph=tf.Graph()) as sess:
   ...
-  builder.add_meta_graph([tag_constants.SERVING])
+  builder.add_meta_graph([tag_constants.SERVING], strip_default_attrs=True)
 ...
 builder.save()
 ```
 
+<a name="forward_compatibility"></a>
+#### Forward compatibility via `strip_default_attrs=True`
 
-### Load a SavedModel in Python
+Following the guidance below gives you forward compatibility only if the set of
+Ops has not changed.
+
+The @{tf.saved_model.builder.SavedModelBuilder$`SavedModelBuilder`} class allows
+users to control whether default-valued attributes must be stripped from the
+@{$extend/tool_developers#nodes$`NodeDefs`}
+while adding a meta graph to the SavedModel bundle. Both
+@{tf.saved_model.builder.SavedModelBuilder.add_meta_graph_and_variables$`SavedModelBuilder.add_meta_graph_and_variables`}
+and @{tf.saved_model.builder.SavedModelBuilder.add_meta_graph$`SavedModelBuilder.add_meta_graph`}
+methods accept a Boolean flag `strip_default_attrs` that controls this behavior.
+
+If `strip_default_attrs` is `False`, the exported @{tf.MetaGraphDef} will have
+the default valued attributes in all its @{tf.NodeDef} instances.
+This can break forward compatibility with a sequence of events such as the
+following:
+
+*  An existing Op (`Foo`) is updated to include a new attribute (`T`) with a
+   default (`bool`) at version 101.
+*  A model producer such as a "trainer binary" picks up this change (version 101)
+   to the `OpDef` and re-exports an existing model that uses Op `Foo`.
+*  A model consumer (such as [Tensorflow Serving](/serving)) running an older
+   binary (version 100) doesn't have attribute `T` for Op `Foo`, but tries to
+   import this model. The model consumer doesn't recognize attribute `T` in a
+   `NodeDef` that uses Op `Foo` and therefore fails to load the model.
+*  By setting `strip_default_attrs` to True, the model producers can strip away
+   any default valued attributes in the `NodeDefs`. This helps ensure that newly
+   added attributes with defaults don't cause older model consumers to fail
+   loading models regenerated with newer training binaries.
+
+See [compatibility guidance](https://www.tensorflow.org/programmers_guide/version_compat)
+for more information.
+
+### Loading a SavedModel in Python
 
 The Python version of the SavedModel
 @{tf.saved_model.loader$loader}
@@ -365,7 +400,7 @@ defined in:
 
 After training an `Estimator` model, you may want to create a service
 from that model that takes requests and returns a result.  You can run such a
-service locally on your machine or deploy it scalably in the cloud.
+service locally on your machine or deploy it in the cloud.
 
 To prepare a trained Estimator for serving, you must export it in the standard
 SavedModel format. This section explains how to:
@@ -458,7 +493,8 @@ To export your trained Estimator, call
 the `serving_input_receiver_fn`.
 
 ```py
-estimator.export_savedmodel(export_dir_base, serving_input_receiver_fn)
+estimator.export_savedmodel(export_dir_base, serving_input_receiver_fn,
+                            strip_default_attrs=True)
 ```
 
 This method builds a new graph by first calling the
diff --git a/programmers_guide/summaries_and_tensorboard.md b/programmers_guide/summaries_and_tensorboard.md
index 79280d2..fadfa03 100644
--- a/programmers_guide/summaries_and_tensorboard.md
+++ b/programmers_guide/summaries_and_tensorboard.md
@@ -83,7 +83,7 @@ data than you need, though. Instead, consider running the merged summary op
 every `n` steps.
 
 The code example below is a modification of the
-@{$layers$simple MNIST tutorial},
+[simple MNIST tutorial](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/examples/tutorials/mnist/mnist.py),
 in which we have added some summary ops, and run them every ten steps. If you
 run this and then launch `tensorboard --logdir=/tmp/tensorflow/mnist`, you'll be able
 to visualize statistics, such as how the weights or accuracy varied during
diff --git a/programmers_guide/using_tpu.md b/programmers_guide/using_tpu.md
index d74d7f3..cb0d86f 100644
--- a/programmers_guide/using_tpu.md
+++ b/programmers_guide/using_tpu.md
@@ -11,7 +11,7 @@ This doc is aimed at users who:
   using an existing model.
 * Have, perhaps, skimmed the code of an example TPU model
   [[1]](https://github.com/tensorflow/models/blob/master/official/mnist/mnist_tpu.py)
-  [[2]](https://github.com/tensorflow/tpu-demos/tree/master/cloud_tpu/models).
+  [[2]](https://github.com/tensorflow/tpu/tree/master/models).
 * Are interested in porting an existing `Estimator` model to
   run on Cloud TPUs
 
@@ -129,10 +129,9 @@ my_tpu_estimator = tf.contrib.tpu.TPUEstimator(
 Typically the `FLAGS` would be set by command line arguments. To switch from
 training locally to training on a cloud TPU you would need to:
 
-  1) Set `FLAGS.use_tpu` to `True`
-  1) Set `FLAGS.tpu_name` so the
-     `tf.contrib.cluster_resolver.TPUClusterResolver` can find it
-  1) Set `FLAGS.model_dir` to a Google Cloud Storage bucket url (`gs://`).
+* Set `FLAGS.use_tpu` to `True`
+* Set `FLAGS.tpu_name` so the `tf.contrib.cluster_resolver.TPUClusterResolver` can find it
+* Set `FLAGS.model_dir` to a Google Cloud Storage bucket url (`gs://`).
 
 
 ## Optimizer
@@ -289,7 +288,7 @@ If shape inference has failed, but the shape is known it is possible to
 impose the correct shape using `tf.set_shape()`. 
 
 In the example below the shape
-inference algorithm fails, but it is corrected using `set_shape`:
+inference algorithm fails, but it is correctly using `set_shape`:
 
 ```
 >>> x = tf.zeros(tf.constant([1,2,3])+1)
@@ -372,10 +371,10 @@ in bytes. A minimum of a few MB (`buffer_size=8*1024*1024`) is recommended so
 that data is available when needed.
 
 The TPU-demos repo includes
-[a script](https://github.com/tensorflow/tpu-demos/blob/master/cloud_tpu/datasets/imagenet_to_gcs.py)
+[a script](https://github.com/tensorflow/tpu/blob/master/tools/datasets/imagenet_to_gcs.py)
 for downloading the imagenet dataset and converting it to an appropriate format.
 This together with the imagenet
-[models](https://github.com/tensorflow/tpu-demos/tree/master/cloud_tpu/models)
+[models](https://github.com/tensorflow/tpu/tree/master/models)
 included in the repo demonstrate all of these best-practices.
 
 
@@ -388,7 +387,7 @@ For details on how to actually set up and run a Cloud TPU see:
 This document is by no means exhaustive. The best source of more detail on how
 to make a Cloud TPU compatible model are the example models published in:
 
- * The [TPU Demos Repository.](https://github.com/tensorflow/tpu-demos/)
+ * The [TPU Demos Repository.](https://github.com/tensorflow/tpu)
 
 For more information about tuning TensorFlow code for performance see:
 
diff --git a/programmers_guide/version_compat.md b/programmers_guide/version_compat.md
index e6613cc..72e427c 100644
--- a/programmers_guide/version_compat.md
+++ b/programmers_guide/version_compat.md
@@ -183,7 +183,7 @@ Our versioning scheme has three requirements:
 *   **Forward compatibility** to support scenarios where the producer of a
     graph or checkpoint is upgraded to a newer version of TensorFlow before
     the consumer.
-*   Enable evolving TensorFlow in incompatible ways. For example, removing Ops,
+*   Enable evolving TensorFlow in incompatible ways. For example, removing ops,
     adding attributes, and removing attributes.
 
 Note that while the `GraphDef` version mechanism is separate from the TensorFlow
@@ -245,32 +245,51 @@ contains a main data version which is treated as either `producer` or
     `TF_CHECKPOINT_VERSION_MIN_CONSUMER`, and
     `TF_CHECKPOINT_VERSION_MIN_PRODUCER`.
 
+### Add a new attribute with default to an existing op
+
+Following the guidance below gives you forward compatibility only if the set of
+ops has not changed:
+
+1. If forward compatibility is desired,  set `strip_default_attrs` to `True`
+   while exporting the model using either the
+   @{tf.saved_model.builder.SavedModelBuilder.add_meta_graph_and_variables$`add_meta_graph_and_variables`}
+   and @{tf.saved_model.builder.SavedModelBuilder.add_meta_graph$`add_meta_graph`}
+   methods of the `SavedModelBuilder` class, or
+   @{tf.estimator.Estimator.export_savedmodel$`Estimator.export_savedmodel`}
+2. This strips off the default valued attributes at the time of
+   producing/exporting the models. This makes sure that the exported
+   @{tf.MetaGraphDef} does not contain the new op-attribute when the default
+   value is used.
+3. Having this control could allow out-of-date consumers (for example, serving
+   binaries that lag behind training binaries) to continue loading the models
+   and prevent interruptions in model serving.
+
 ### Evolving GraphDef versions
 
 This section explains how to use this versioning mechanism to make different
 types of changes to the `GraphDef` format.
 
-#### Add an Op
+#### Add an op
 
-Add the new Op to both consumers and producers at the same time, and do not
+Add the new op to both consumers and producers at the same time, and do not
 change any `GraphDef` versions. This type of change is automatically
 backward compatible, and does not impact forward compatibility plan since
 existing producer scripts will not suddenly use the new functionality.
 
-#### Add an Op and switch existing Python wrappers to use it
+#### Add an op and switch existing Python wrappers to use it
 
 1.  Implement new consumer functionality and increment the `GraphDef` version.
 2.  If it is possible to make the wrappers use the new functionality only in
     cases that did not work before, the wrappers can be updated now.
 3.  Change Python wrappers to use the new functionality. Do not increment
-    `min_consumer`, since models that do not use this Op should not break.
+    `min_consumer`, since models that do not use this op should not break.
 
-#### Remove or restrict an Op's functionality
+#### Remove or restrict an op's functionality
 
-1.  Fix all producer scripts (not TensorFlow itself) to not use the banned Op or
+1.  Fix all producer scripts (not TensorFlow itself) to not use the banned op or
     functionality.
 2.  Increment the `GraphDef` version and implement new consumer functionality
-    that bans the removed Op or functionality for GraphDefs at the new version
+    that bans the removed op or functionality for GraphDefs at the new version
     and above. If possible, make TensorFlow stop producing `GraphDefs` with the
     banned functionality. To do so, add the
     [`REGISTER_OP(...).Deprecated(deprecated_at_version,
@@ -279,15 +298,15 @@ existing producer scripts will not suddenly use the new functionality.
 4.  Increase `min_producer` to the GraphDef version from (2) and remove the
     functionality entirely.
 
-#### Change an Op's functionality
+#### Change an op's functionality
 
-1.  Add a new similar Op named `SomethingV2` or similar and go through the
+1.  Add a new similar op named `SomethingV2` or similar and go through the
     process of adding it and switching existing Python wrappers to use it, which
     may take three weeks if forward compatibility is desired.
-2.  Remove the old Op (Can only take place with a major version change due to
+2.  Remove the old op (Can only take place with a major version change due to
     backward compatibility).
-3.  Increase `min_consumer` to rule out consumers with the old Op, add back the
-    old Op as an alias for `SomethingV2`, and go through the process to switch
+3.  Increase `min_consumer` to rule out consumers with the old op, add back the
+    old op as an alias for `SomethingV2`, and go through the process to switch
     existing Python wrappers to use it.
 4.  Go through the process to remove `SomethingV2`.
 
@@ -295,6 +314,6 @@ existing producer scripts will not suddenly use the new functionality.
 
 1.  Bump the `GraphDef` version and add the bad version to `bad_consumers` for
     all new GraphDefs. If possible, add to `bad_consumers` only for GraphDefs
-    which contain a certain Op or similar.
+    which contain a certain op or similar.
 2.  If existing consumers have the bad version, push them out as soon as
     possible.
diff --git a/tutorials/deep_cnn.md b/tutorials/deep_cnn.md
index 6797540..6a4c9a9 100644
--- a/tutorials/deep_cnn.md
+++ b/tutorials/deep_cnn.md
@@ -268,7 +268,7 @@ in `cifar10_input.py`.
 
 `cifar10_train.py` periodically @{tf.train.Saver$saves}
 all model parameters in
-@{$variables#saving-and-restoring$checkpoint files}
+@{$programmers_guide/saved_model$checkpoint files}
 but it does *not* evaluate the model. The checkpoint file
 will be used by `cifar10_eval.py` to measure the predictive
 performance (see [Evaluating a Model](#evaluating-a-model) below).
diff --git a/tutorials/image_retraining.md b/tutorials/image_retraining.md
index 246a420..93d7c86 100644
--- a/tutorials/image_retraining.md
+++ b/tutorials/image_retraining.md
@@ -115,7 +115,7 @@ process is progressing. The training's objective is to make the loss as small as
 possible, so you can tell if the learning is working by keeping an eye on
 whether the loss keeps trending downwards, ignoring the short-term noise.
 
-By default this script will run 4,000 training steps. Each step chooses ten
+By default this script will run 4,000 training steps. Each step chooses 100
 images at random from the training set, finds their bottlenecks from the cache,
 and feeds them into the final layer to get predictions. Those predictions are
 then compared against the actual labels to update the final layer's weights
diff --git a/tutorials/kernel_methods.md b/tutorials/kernel_methods.md
index 63f408c..73e5c51 100644
--- a/tutorials/kernel_methods.md
+++ b/tutorials/kernel_methods.md
@@ -1,9 +1,9 @@
 # Improving Linear Models Using Explicit Kernel Methods
 
-Note: This document uses a deprecated version of ${tf.estimator},
-which has a ${tf.contrib.learn.estimator$different interface}.
+Note: This document uses a deprecated version of @{tf.estimator},
+which has a @{tf.contrib.learn.Estimator$different interface}.
 It also uses other `contrib` methods whose
-${$version_compat#not_covered$API may not be stable}.
+@{$version_compat#not_covered$API may not be stable}.
 
 In this tutorial, we demonstrate how combining (explicit) kernel methods with
 linear models can drastically increase the latters' quality of predictions
@@ -53,7 +53,7 @@ In order to feed data to a `tf.contrib.learn Estimator`, it is helpful to conver
 it to Tensors. For this, we will use an `input function` which adds Ops to the
 TensorFlow graph that, when executed, create mini-batches of Tensors to be used
 downstream. For more background on input functions, check
-@{$get_started/premade_estimators#input_fn$this section on input functions}.
+@{$get_started/premade_estimators#create_input_functions$this section on input functions}.
 In this example, we will use the `tf.train.shuffle_batch` Op which, besides
 converting numpy arrays to Tensors, allows us to specify the batch_size and
 whether to randomize the input every time the input_fn Ops are executed
diff --git a/tutorials/layers.md b/tutorials/layers.md
index ee03f44..cadaec3 100644
--- a/tutorials/layers.md
+++ b/tutorials/layers.md
@@ -193,22 +193,28 @@ to calculate loss, configure the training op, and generate predictions. If
 you're already experienced with CNNs and @{$get_started/custom_estimators$TensorFlow `Estimator`s},
 and find the above code intuitive, you may want to skim these sections or just
 skip ahead to ["Training and Evaluating the CNN MNIST
-Classifier"](#training-and-evaluating-the-cnn-mnist-classifier).
+Classifier"](#training_and_evaluating_the_cnn_mnist_classifier).
 
 ### Input Layer
 
 The methods in the `layers` module for creating convolutional and pooling layers
 for two-dimensional image data expect input tensors to have a shape of
-<code>[<em>batch_size</em>, <em>image_width</em>, <em>image_height</em>,
-<em>channels</em>]</code>, defined as follows:
+<code>[<em>batch_size</em>, <em>image_height</em>, <em>image_width</em>,
+<em>channels</em>]</code> by default. This behavior can be changed using the <code><em>data_format</em></code> parameter; defined as follows:
+
 
 *   _`batch_size`_. Size of the subset of examples to use when performing
     gradient descent during training.
-*   _`image_width`_. Width of the example images.
 *   _`image_height`_. Height of the example images.
+*   _`image_width`_. Width of the example images.
 *   _`channels`_. Number of color channels in the example images. For color
     images, the number of channels is 3 (red, green, blue). For monochrome
     images, there is just 1 channel (black).
+*   _`image_height`_. Height of the example images.
+*   _`data_format`_. A string, one of `channels_last` (default) or `channels_first`.
+      `channels_last` corresponds to inputs with shape
+      `(batch, ..., channels)` while `channels_first` corresponds to
+      inputs with shape `(batch, channels, ...)`.
 
 Here, our MNIST dataset is composed of monochrome 28x28 pixel images, so the
 desired shape for our input layer is <code>[<em>batch_size</em>, 28, 28,
@@ -247,28 +253,27 @@ conv1 = tf.layers.conv2d(
 ```
 
 The `inputs` argument specifies our input tensor, which must have the shape
-<code>[<em>batch_size</em>, <em>image_width</em>, <em>image_height</em>,
+<code>[<em>batch_size</em>, <em>image_height</em>, <em>image_width</em>,
 <em>channels</em>]</code>. Here, we're connecting our first convolutional layer
 to `input_layer`, which has the shape <code>[<em>batch_size</em>, 28, 28,
 1]</code>.
 
 > Note: <code>conv2d()</code> will instead accept a shape of
-> <code>[<em>channels</em>, <em>batch_size</em>, <em>image_width</em>,
-> <em>image_height</em>]</code> when passed the argument
+> <code>[<em>batch_size</em>, <em>channels</em>, <em>image_height</em>, <em>image_width</em>]</code> when passed the argument
 > <code>data_format=channels_first</code>.
 
 The `filters` argument specifies the number of filters to apply (here, 32), and
-`kernel_size` specifies the dimensions of the filters as <code>[<em>width</em>,
-<em>height</em>]</code> (here, <code>[5, 5]</code>).
+`kernel_size` specifies the dimensions of the filters as <code>[<em>height</em>,
+<em>width</em>]</code> (here, <code>[5, 5]</code>).
 
-<p class="tip"><b>TIP:</b> If filter width and height have the same value, you can instead specify a
+<p class="tip"><b>TIP:</b> If filter height and width have the same value, you can instead specify a
 single integer for <code>kernel_size</code>—e.g., <code>kernel_size=5</code>.</p>
 
 The `padding` argument specifies one of two enumerated values
 (case-insensitive): `valid` (default value) or `same`. To specify that the
-output tensor should have the same width and height values as the input tensor,
+output tensor should have the same height and width values as the input tensor,
 we set `padding=same` here, which instructs TensorFlow to add 0 values to the
-edges of the input tensor to preserve width and height of 28. (Without padding,
+edges of the input tensor to preserve height and width of 28. (Without padding,
 a 5x5 convolution over a 28x28 tensor will produce a 24x24 tensor, as there are
 24x24 locations to extract a 5x5 tile from a 28x28 grid.)
 
@@ -277,7 +282,7 @@ output of the convolution. Here, we specify ReLU activation with
 @{tf.nn.relu}.
 
 Our output tensor produced by `conv2d()` has a shape of
-<code>[<em>batch_size</em>, 28, 28, 32]</code>: the same width and height
+<code>[<em>batch_size</em>, 28, 28, 32]</code>: the same height and width
 dimensions as the input, but now with 32 channels holding the output from each
 of the filters.
 
@@ -292,31 +297,30 @@ pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
 ```
 
 Again, `inputs` specifies the input tensor, with a shape of
-<code>[<em>batch_size</em>, <em>image_width</em>, <em>image_height</em>,
+<code>[<em>batch_size</em>, <em>image_height</em>, <em>image_width</em>,
 <em>channels</em>]</code>. Here, our input tensor is `conv1`, the output from
 the first convolutional layer, which has a shape of <code>[<em>batch_size</em>,
 28, 28, 32]</code>.
 
 > Note: As with <code>conv2d()</code>, <code>max_pooling2d()</code> will instead
-> accept a shape of <code>[<em>channels</em>, <em>batch_size</em>,
-> <em>image_width</em>, <em>image_height</em>]</code> when passed the argument
+> accept a shape of <code>[<em>batch_size</em>, <em>channels</em>, 
+> <em>image_height</em>, <em>image_width</em>]</code> when passed the argument
 > <code>data_format=channels_first</code>.
 
 The `pool_size` argument specifies the size of the max pooling filter as
-<code>[<em>width</em>, <em>height</em>]</code> (here, `[2, 2]`). If both
+<code>[<em>height</em>, <em>width</em>]</code> (here, `[2, 2]`). If both
 dimensions have the same value, you can instead specify a single integer (e.g.,
 `pool_size=2`).
 
 The `strides` argument specifies the size of the stride. Here, we set a stride
 of 2, which indicates that the subregions extracted by the filter should be
-separated by 2 pixels in both the width and height dimensions (for a 2x2 filter,
+separated by 2 pixels in both the height and width dimensions (for a 2x2 filter,
 this means that none of the regions extracted will overlap). If you want to set
-different stride values for width and height, you can instead specify a tuple or
+different stride values for height and width, you can instead specify a tuple or
 list (e.g., `stride=[3, 6]`).
 
 Our output tensor produced by `max_pooling2d()` (`pool1`) has a shape of
-<code>[<em>batch_size</em>, 14, 14, 32]</code>: the 2x2 filter reduces width and
-height by 50% each.
+<code>[<em>batch_size</em>, 14, 14, 32]</code>: the 2x2 filter reduces height and width by 50% each.
 
 ### Convolutional Layer #2 and Pooling Layer #2
 
@@ -338,13 +342,11 @@ pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)
 
 Note that convolutional layer #2 takes the output tensor of our first pooling
 layer (`pool1`) as input, and produces the tensor `conv2` as output. `conv2`
-has a shape of <code>[<em>batch_size</em>, 14, 14, 64]</code>, the same width
-and height as `pool1` (due to `padding="same"`), and 64 channels for the 64
+has a shape of <code>[<em>batch_size</em>, 14, 14, 64]</code>, the same height and width as `pool1` (due to `padding="same"`), and 64 channels for the 64
 filters applied.
 
 Pooling layer #2 takes `conv2` as input, producing `pool2` as output. `pool2`
-has shape <code>[<em>batch_size</em>, 7, 7, 64]</code> (50% reduction of width
-and height from `conv2`).
+has shape <code>[<em>batch_size</em>, 7, 7, 64]</code> (50% reduction of height and width from `conv2`).
 
 ### Dense Layer
 
@@ -360,7 +362,7 @@ pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 64])
 
 In the `reshape()` operation above, the `-1` signifies that the *`batch_size`*
 dimension will be dynamically calculated based on the number of examples in our
-input data. Each example has 7 (`pool2` width) * 7 (`pool2` height) * 64
+input data. Each example has 7 (`pool2` height) * 7 (`pool2` width) * 64
 (`pool2` channels) features, so we want the `features` dimension to have a value
 of 7 * 7 * 64 (3136 in total). The output tensor, `pool2_flat`, has shape
 <code>[<em>batch_size</em>, 3136]</code>.
@@ -446,7 +448,7 @@ tf.nn.softmax(logits, name="softmax_tensor")
 
 > Note: We use the `name` argument to explicitly name this operation
 > `softmax_tensor`, so we can reference it later. (We'll set up logging for the
-> softmax values in ["Set Up a Logging Hook"](#set-up-a-logging-hook).
+> softmax values in ["Set Up a Logging Hook"](#set-up-a-logging-hook)).
 
 We compile our predictions in a dict, and return an `EstimatorSpec` object:
 
@@ -534,9 +536,8 @@ if mode == tf.estimator.ModeKeys.TRAIN:
 ```
 
 > Note: For a more in-depth look at configuring training ops for Estimator model
-> functions, see @{$get_started/custom_estimators#defining-the-training-op-for-the-model$"Defining
-> the training op for the model"} in the @{$get_started/custom_estimators$"Creating Estimations in
-> tf.estimator"} tutorial.
+> functions, see @{$get_started/custom_estimators#defining_the_training_op_for_the_model$"Defining the training op for the model"} 
+> in the @{$get_started/custom_estimators$"Creating Estimators in tf.estimator."} tutorial.
 
 ### Add evaluation metrics
 
@@ -625,7 +626,8 @@ operation earlier when we generated the probabilities in `cnn_model_fn`.
 > Note: If you don't explicitly assign a name to an operation via the `name`
 > argument, TensorFlow will assign a default name. A couple easy ways to
 > discover the names applied to operations are to visualize your graph on
-> @{$graph_viz$TensorBoard}) or to enable the @{$debugger$TensorFlow Debugger (tfdbg)}.
+> @{$graph_viz$TensorBoard}) or to enable the
+> @{$programmers_guide/debugger$TensorFlow Debugger (tfdbg)}.
 
 Next, we create the `LoggingTensorHook`, passing `tensors_to_log` to the
 `tensors` argument. We set `every_n_iter=50`, which specifies that probabilities
diff --git a/tutorials/recurrent_quickdraw.md b/tutorials/recurrent_quickdraw.md
index e22536a..5d83fbe 100644
--- a/tutorials/recurrent_quickdraw.md
+++ b/tutorials/recurrent_quickdraw.md
@@ -38,8 +38,8 @@ To try the code for this tutorial:
 1.  [Download the data](#download-the-data) in `TFRecord` format from
     [here](http://download.tensorflow.org/data/quickdraw_tutorial_dataset_v1.tar.gz) and unzip it. More details about [how to
     obtain the original Quick, Draw!
-    data](#optional-download-the-full-quick-draw-data) and [how to convert that
-    to `TFRecord` files](#optional-converting-the-data) is available below.
+    data](#optional_download_the_full_quick_draw_data) and [how to convert that
+    to `TFRecord` files](#optional_converting_the_data) is available below.
 
 1.  Execute the tutorial code with the following command to train the RNN-based
     model described in this tutorial. Make sure to adjust the paths to point to
@@ -108,8 +108,9 @@ This download will take a while and download a bit more than 23GB of data.
 ### Optional: Converting the data
 
 To convert the `ndjson` files to
-@{$python/python_io#tfrecords_format_details$TFRecord} files containing
-${tf.train.Example} protos run the following command.
+@{$python/python_io#TFRecords_Format_Details$TFRecord} files containing
+[`tf.train.Example`](https://www.tensorflow.org/code/tensorflow/core/example/example.proto)
+protos run the following command.
 
 ```shell
    python create_dataset.py --ndjson_path rnn_tutorial_data \
@@ -117,7 +118,7 @@ ${tf.train.Example} protos run the following command.
 ```
 
 This will store the data in 10 shards of
-@{$python/python_io#tfrecords_format_details$TFRecord} files with 10000 items
+@{$python/python_io#TFRecords_Format_Details$TFRecord} files with 10000 items
 per class for the training data and 1000 items per class as eval data.
 
 This conversion process is described in more detail in the following.
diff --git a/tutorials/wide.md b/tutorials/wide.md
index bf6b9d6..27ce75a 100644
--- a/tutorials/wide.md
+++ b/tutorials/wide.md
@@ -74,8 +74,8 @@ Here's a list of columns available in the Census Income dataset:
 | relationship   | Categorical | Wife, Own-child, Husband,         |
 :                :             : Not-in-family, Other-relative,    :
 :                :             : Unmarried.                        :
-| race           | Categorical | White, Asian-Pac-Islander,        |
-:                :             : Amer-Indian-Eskimo, Other, Black. :
+| race           | Categorical | Amer-Indian-Eskimo, Asian-Pac-    |
+:                :             : Islander, Black, White, Other.    :
 | gender         | Categorical | Female, Male.                     |
 | capital_gain   | Continuous  | Capital gains recorded.           |
 | capital_loss   | Continuous  | Capital Losses recorded.          |

From 218e52c62320d7450107b32d6e7794a0a14b6228 Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Sat, 21 Apr 2018 10:38:14 +0800
Subject: [PATCH 5/7] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 99f4a25..29418dc 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@
 
 | **`Documentation`** | **`Linux CPU`** | **`Linux GPU`** | **`Mac OS CPU`** | **`Windows CPU`** | **`Android`** |
 |-----------------|---------------------|------------------|-------------------|---------------|---------------|
-| [![Documentation](https://img.shields.io/badge/api-reference-blue.svg)](https://www.tensorflow.org/api_docs/) | ![Build Status](https://storage.cloud.google.com/tensorflow-kokoro-build-badges/ubuntu-cc.png) | ![Build Status](https://storage.cloud.google.com/tensorflow-kokoro-build-badges/ubuntu-gpu-cc.png) | ![Build Status](https://storage.cloud.google.com/tensorflow-kokoro-build-badges/macos-py2-cc.png) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-win-cmake-py)](https://ci.tensorflow.org/job/tensorflow-master-win-cmake-py) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-android)](https://ci.tensorflow.org/job/tensorflow-master-android) [ ![Download](https://api.bintray.com/packages/google/tensorflow/tensorflow/images/download.svg) ](https://bintray.com/google/tensorflow/tensorflow/_latestVersion)
+| [![Documentation](https://img.shields.io/badge/api-reference-blue.svg)](https://www.tensorflow.org/api_docs/) | ![Build Status](https://storage.googleapis.com/tensorflow-kokoro-build-badges/ubuntu-cc.png) | ![Build Status](https://storage.googleapis.com/tensorflow-kokoro-build-badges/ubuntu-gpu-cc.png) | ![Build Status](https://storage.googleapis.com/tensorflow-kokoro-build-badges/macos-py2-cc.png) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-win-cmake-py)](https://ci.tensorflow.org/job/tensorflow-master-win-cmake-py) | [![Build Status](https://ci.tensorflow.org/buildStatus/icon?job=tensorflow-master-android)](https://ci.tensorflow.org/job/tensorflow-master-android) [ ![Download](https://api.bintray.com/packages/google/tensorflow/tensorflow/images/download.svg) ](https://bintray.com/google/tensorflow/tensorflow/_latestVersion)
 
 **TensorFlow** is an open source software library for numerical computation using
 data flow graphs.  The graph nodes represent mathematical operations, while

From 835db91ad14f98c61d25d6d3cd5a5ac66bd8d56d Mon Sep 17 00:00:00 2001
From: Ding Xue-wen <xuewending1995@gmail.com>
Date: Fri, 13 Jul 2018 13:22:04 +0800
Subject: [PATCH 6/7] update

---
 install/install_c.md       |  2 +-
 install/install_go.md      |  2 +-
 install/install_java.md    | 22 +++++++-------
 install/install_linux.md   | 60 ++++++++++++++++++++++++++------------
 install/install_mac.md     | 10 +++----
 install/install_sources.md |  4 +--
 6 files changed, 61 insertions(+), 39 deletions(-)

diff --git a/install/install_c.md b/install/install_c.md
index 8c165aa..1abd840 100644
--- a/install/install_c.md
+++ b/install/install_c.md
@@ -38,7 +38,7 @@ enable TensorFlow for C:
          OS="linux" # Change to "darwin" for macOS
          TARGET_DIRECTORY="/usr/local"
          curl -L \
-           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-$%7BTF_TYPE%7D-$%7BOS%7D-x86_64-1.8.0-rc1.tar.gz" |
+           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-$%7BTF_TYPE%7D-$%7BOS%7D-x86_64-1.8.0.tar.gz" |
            sudo tar -C $TARGET_DIRECTORY -xz
 
      The `tar` command extracts the TensorFlow C library into the `lib`
diff --git a/install/install_go.md b/install/install_go.md
index 26cbcc9..52a2a3f 100644
--- a/install/install_go.md
+++ b/install/install_go.md
@@ -38,7 +38,7 @@ steps to install this library and enable TensorFlow for Go:
          TF_TYPE="cpu" # Change to "gpu" for GPU support
          TARGET_DIRECTORY='/usr/local'
          curl -L \
-           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-$%7BTF_TYPE%7D-$(go%20env%20GOOS)-x86_64-1.8.0-rc1.tar.gz" |
+           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-$%7BTF_TYPE%7D-$(go%20env%20GOOS)-x86_64-1.8.0.tar.gz" |
          sudo tar -C $TARGET_DIRECTORY -xz
 
      The `tar` command extracts the TensorFlow C library into the `lib`
diff --git a/install/install_java.md b/install/install_java.md
index 1b0bbdb..700ae01 100644
--- a/install/install_java.md
+++ b/install/install_java.md
@@ -36,7 +36,7 @@ following to the project's `pom.xml` to use the TensorFlow Java APIs:
 <dependency>
   <groupId>org.tensorflow</groupId>
   <artifactId>tensorflow</artifactId>
-  <version>1.8.0-rc1</version>
+  <version>1.8.0</version>
 </dependency>
 ```
 
@@ -65,7 +65,7 @@ As an example, these steps will create a Maven project that uses TensorFlow:
                <dependency>
                  <groupId>org.tensorflow</groupId>
                  <artifactId>tensorflow</artifactId>
-                 <version>1.8.0-rc1</version>
+                 <version>1.8.0</version>
                </dependency>
              </dependencies>
          </project>
@@ -123,12 +123,12 @@ instead:
 <dependency>
   <groupId>org.tensorflow</groupId>
   <artifactId>libtensorflow</artifactId>
-  <version>1.8.0-rc1</version>
+  <version>1.8.0</version>
 </dependency>
 <dependency>
   <groupId>org.tensorflow</groupId>
   <artifactId>libtensorflow_jni_gpu</artifactId>
-  <version>1.8.0-rc1</version>
+  <version>1.8.0</version>
 </dependency>
 ```
 
@@ -147,7 +147,7 @@ refer to the simpler instructions above instead.
 Take the following steps to install TensorFlow for Java on Linux or macOS:
 
   1. Download
-     [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.8.0-rc1.jar),
+     [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.8.0.jar),
      which is the TensorFlow Java Archive (JAR).
 
   2. Decide whether you will run TensorFlow for Java on CPU(s) only or with
@@ -166,7 +166,7 @@ Take the following steps to install TensorFlow for Java on Linux or macOS:
          OS=$(uname -s | tr '[:upper:]' '[:lower:]')
          mkdir -p ./jni
          curl -L \
-           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-$%7BTF_TYPE%7D-$%7BOS%7D-x86_64-1.8.0-rc1.tar.gz" |
+           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-$%7BTF_TYPE%7D-$%7BOS%7D-x86_64-1.8.0.tar.gz" |
            tar -xz -C ./jni
 
 ### Install on Windows
@@ -174,10 +174,10 @@ Take the following steps to install TensorFlow for Java on Linux or macOS:
 Take the following steps to install TensorFlow for Java on Windows:
 
   1. Download
-     [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.8.0-rc1.jar),
+     [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.8.0.jar),
      which is the TensorFlow Java Archive (JAR).
   2. Download the following Java Native Interface (JNI) file appropriate for
-     [TensorFlow for Java on Windows](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-cpu-windows-x86_64-1.8.0-rc1.zip).
+     [TensorFlow for Java on Windows](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-cpu-windows-x86_64-1.8.0.zip).
   3. Extract this .zip file.
 
 
@@ -225,7 +225,7 @@ must be part of your `classpath`. For example, you can include the
 downloaded `.jar` in your `classpath` by using the `-cp` compilation flag
 as follows:
 
-<pre><b>javac -cp libtensorflow-1.8.0-rc1.jar HelloTF.java</b></pre>
+<pre><b>javac -cp libtensorflow-1.8.0.jar HelloTF.java</b></pre>
 
 
 ### Running
@@ -239,11 +239,11 @@ two files are available to the JVM:
 For example, the following command line executes the `HelloTF` program on Linux
 and macOS X:
 
-<pre><b>java -cp libtensorflow-1.8.0-rc1.jar:. -Djava.library.path=./jni HelloTF</b></pre>
+<pre><b>java -cp libtensorflow-1.8.0.jar:. -Djava.library.path=./jni HelloTF</b></pre>
 
 And the following command line executes the `HelloTF` program on Windows:
 
-<pre><b>java -cp libtensorflow-1.8.0-rc1.jar;. -Djava.library.path=jni HelloTF</b></pre>
+<pre><b>java -cp libtensorflow-1.8.0.jar;. -Djava.library.path=jni HelloTF</b></pre>
 
 If the program prints <tt>Hello from <i>version</i></tt>, you've successfully
 installed TensorFlow for Java and are ready to use the API.  If the program
diff --git a/install/install_linux.md b/install/install_linux.md
index f19f827..16a232e 100644
--- a/install/install_linux.md
+++ b/install/install_linux.md
@@ -48,7 +48,7 @@ must be installed on your system:
     Toolkit.
   * The libcupti-dev library, which is the NVIDIA CUDA Profile Tools Interface.
     This library provides advanced profiling support. To install this library,
-    issue the following command for CUDA Toolkit >= 8.0:
+    issue the following command for CUDA Toolkit >= 9.0:
 
     <pre>
     $ <b>sudo apt-get install cuda-command-line-tools</b>
@@ -65,16 +65,38 @@ must be installed on your system:
     <pre>
     $ <b>sudo apt-get install libcupti-dev</b>
     </pre>
+
   * **[OPTIONAL]**  For optimized inferencing performance, you can also install
-    NVIDIA TensorRT 3.0. For details, see
-    [NVIDIA's TensorRT documentation](http://docs.nvidia.com/deeplearning/sdk/tensorrt-install-guide/index.html#installing-tar).
-    Only steps 1-4 in the TensorRT Tar File installation instructions are
-    required for compatibility with TensorFlow; the Python package installation
-    in steps 5 and 6 can be omitted. Detailed installation instructions can be found at [package documentataion](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/tensorrt#installing-tensorrt-304)
+    **NVIDIA TensorRT 3.0**. The minimal set of TensorRT runtime components needed
+    for use with the pre-built `tensorflow-gpu` package can be installed as follows:
+
+    <pre>
+    $ <b>wget https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1404/x86_64/nvinfer-runtime-trt-repo-ubuntu1404-3.0.4-ga-cuda9.0_1.0-1_amd64.deb</b>
+    $ <b>sudo dpkg -i nvinfer-runtime-trt-repo-ubuntu1404-3.0.4-ga-cuda9.0_1.0-1_amd64.deb</b>
+    $ <b>sudo apt-get update</b>
+    $ <b>sudo apt-get install -y --allow-downgrades libnvinfer-dev libcudnn7-dev=7.0.5.15-1+cuda9.0 libcudnn7=7.0.5.15-1+cuda9.0</b>
+    </pre>
 
     **IMPORTANT:** For compatibility with the pre-built `tensorflow-gpu`
-    package, please use the Ubuntu **14.04** tar file package of TensorRT
-    even when installing onto an Ubuntu 16.04 system.   
+    package, please use the Ubuntu **14.04** package of TensorRT as shown above,
+    even when installing onto an Ubuntu 16.04 system.<br/>
+    <br/>
+    To build the TensorFlow-TensorRT integration module from source rather than
+    using pre-built binaries, see the [module documentation](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/tensorrt#using-tensorrt-in-tensorflow).
+    For detailed TensorRT installation instructions, see [NVIDIA's TensorRT documentation](http://docs.nvidia.com/deeplearning/sdk/tensorrt-install-guide/index.html).<br/>
+    <br/>
+    To avoid cuDNN version conflicts during later system upgrades, you can hold
+    the cuDNN version at 7.0.5:
+
+    <pre>
+    $ <b> sudo apt-mark hold libcudnn7 libcudnn7-dev</b>
+    </pre>
+
+    To later allow upgrades, you can remove the hold:
+
+    <pre>
+    $ <b> sudo apt-mark unhold libcudnn7 libcudnn7-dev</b>
+    </pre>
 
 If you have an earlier version of the preceding packages, please upgrade to
 the specified versions. If upgrading is not possible, then you may still run
@@ -194,7 +216,7 @@ Take the following steps to install TensorFlow with Virtualenv:
      Virtualenv environment:
 
      <pre>(tensorflow)$ <b>pip3 install --upgrade \
-     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0rc1-cp34-cp34m-linux_x86_64.whl</b></pre>
+     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0-cp34-cp34m-linux_x86_64.whl</b></pre>
 
 If you encounter installation problems, see
 [Common Installation Problems](#common_installation_problems).
@@ -299,7 +321,7 @@ take the following steps:
 
      <pre>
      $ <b>sudo pip3 install --upgrade \
-     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0rc1-cp34-cp34m-linux_x86_64.whl</b>
+     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0-cp34-cp34m-linux_x86_64.whl</b>
      </pre>
 
      If this step fails, see
@@ -485,7 +507,7 @@ Take the following steps to install TensorFlow in an Anaconda environment:
 
      <pre>
      (tensorflow)$ <b>pip install --ignore-installed --upgrade \
-     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0rc1-cp34-cp34m-linux_x86_64.whl</b></pre>
+     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0-cp34-cp34m-linux_x86_64.whl</b></pre>
 
 <a name="ValidateYourInstallation"></a>
 ## Validate your installation
@@ -659,14 +681,14 @@ This section documents the relevant values for Linux installations.
 CPU only:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0rc1-cp27-none-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0-cp27-none-linux_x86_64.whl
 </pre>
 
 
 GPU support:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.8.0rc1-cp27-none-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.8.0-cp27-none-linux_x86_64.whl
 </pre>
 
 Note that GPU support requires the NVIDIA hardware and software described in
@@ -678,14 +700,14 @@ Note that GPU support requires the NVIDIA hardware and software described in
 CPU only:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0rc1-cp34-cp34m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0-cp34-cp34m-linux_x86_64.whl
 </pre>
 
 
 GPU support:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.8.0rc1-cp34-cp34m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.8.0-cp34-cp34m-linux_x86_64.whl
 </pre>
 
 Note that GPU support requires the NVIDIA hardware and software described in
@@ -697,14 +719,14 @@ Note that GPU support requires the NVIDIA hardware and software described in
 CPU only:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0rc1-cp35-cp35m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0-cp35-cp35m-linux_x86_64.whl
 </pre>
 
 
 GPU support:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.8.0rc1-cp35-cp35m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.8.0-cp35-cp35m-linux_x86_64.whl
 </pre>
 
 
@@ -716,14 +738,14 @@ Note that GPU support requires the NVIDIA hardware and software described in
 CPU only:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0rc1-cp36-cp36m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0-cp36-cp36m-linux_x86_64.whl
 </pre>
 
 
 GPU support:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.8.0rc1-cp36-cp36m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.8.0-cp36-cp36m-linux_x86_64.whl
 </pre>
 
 
diff --git a/install/install_mac.md b/install/install_mac.md
index ff6c2f5..c79075b 100644
--- a/install/install_mac.md
+++ b/install/install_mac.md
@@ -119,7 +119,7 @@ Take the following steps to install TensorFlow with Virtualenv:
      TensorFlow in the active Virtualenv is as follows:
 
      <pre> $ <b>pip3 install --upgrade \
-     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.8.0rc1-py3-none-any.whl</b></pre>
+     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.8.0-py3-none-any.whl</b></pre>
 
 If you encounter installation problems, see
 [Common Installation Problems](#common-installation-problems).
@@ -242,7 +242,7 @@ take the following steps:
      issue the following command:
 
      <pre> $ <b>sudo pip3 install --upgrade \
-     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.8.0rc1-py3-none-any.whl</b> </pre>
+     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.8.0-py3-none-any.whl</b> </pre>
 
      If the preceding command fails, see
      [installation problems](#common-installation-problems).
@@ -350,7 +350,7 @@ Take the following steps to install TensorFlow in an Anaconda environment:
      TensorFlow for Python 2.7:
 
      <pre> (<i>targetDirectory</i>)$ <b>pip install --ignore-installed --upgrade \
-     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.8.0rc1-py2-none-any.whl</b></pre>
+     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.8.0-py2-none-any.whl</b></pre>
 
 
 <a name="ValidateYourInstallation"></a>
@@ -524,7 +524,7 @@ The value you specify depends on your Python version.
 
 
 <pre>
-https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.8.0rc1-py2-none-any.whl
+https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.8.0-py2-none-any.whl
 </pre>
 
 
@@ -532,5 +532,5 @@ https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.8.0rc1-py2-none-a
 
 
 <pre>
-https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.8.0rc1-py3-none-any.whl
+https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.8.0-py3-none-any.whl
 </pre>
diff --git a/install/install_sources.md b/install/install_sources.md
index d48a6ee..3d93736 100644
--- a/install/install_sources.md
+++ b/install/install_sources.md
@@ -350,10 +350,10 @@ Invoke `pip install` to install that pip package.
 The filename of the `.whl` file depends on your platform.
 For example, the following command will install the pip package
 
-for TensorFlow 1.8.0rc1 on Linux:
+for TensorFlow 1.8.0 on Linux:
 
 <pre>
-$ <b>sudo pip install /tmp/tensorflow_pkg/tensorflow-1.8.0rc1-py2-none-any.whl</b>
+$ <b>sudo pip install /tmp/tensorflow_pkg/tensorflow-1.8.0-py2-none-any.whl</b>
 </pre>
 
 ## Validate your installation

From 3a05e682ea59c34fb8a5a72d427fe97cea6948d6 Mon Sep 17 00:00:00 2001
From: Ding Xue-wen <xuewending1995@gmail.com>
Date: Thu, 4 Oct 2018 21:22:18 +0800
Subject: [PATCH 7/7] update api-guides to v1.10

---
 api_guides/cc/guide.md                        |  20 +-
 api_guides/python/array_ops.md                | 120 +++----
 api_guides/python/check_ops.md                |  34 +-
 api_guides/python/client.md                   |  50 +--
 api_guides/python/constant_op.md              |  40 +--
 .../python/contrib.bayesflow.monte_carlo.md   |  54 ---
 api_guides/python/contrib.crf.md              |  14 +-
 .../python/contrib.distributions.bijectors.md |  32 --
 api_guides/python/contrib.distributions.md    |  83 -----
 api_guides/python/contrib.ffmpeg.md           |   4 +-
 api_guides/python/contrib.framework.md        |  97 ++---
 api_guides/python/contrib.graph_editor.md     | 114 +++---
 api_guides/python/contrib.integrate.md        |   4 +-
 api_guides/python/contrib.layers.md           | 118 +++----
 api_guides/python/contrib.learn.md            |  77 ++--
 api_guides/python/contrib.linalg.md           |  16 +-
 api_guides/python/contrib.losses.md           |  30 +-
 api_guides/python/contrib.metrics.md          |  84 ++---
 api_guides/python/contrib.rnn.md              |  60 ++--
 api_guides/python/contrib.seq2seq.md          |  36 +-
 api_guides/python/contrib.signal.md           |  16 +-
 api_guides/python/contrib.staging.md          |   2 +-
 api_guides/python/contrib.training.md         |  34 +-
 api_guides/python/contrib.util.md             |  10 +-
 api_guides/python/control_flow_ops.md         |  56 +--
 api_guides/python/framework.md                |  58 +--
 api_guides/python/functional_ops.md           |  10 +-
 api_guides/python/image.md                    |  98 ++---
 api_guides/python/input_dataset.md            |  99 +++---
 api_guides/python/io_ops.md                   | 110 +++---
 api_guides/python/math_ops.md                 | 231 ++++++------
 api_guides/python/meta_graph.md               |  20 +-
 api_guides/python/nn.md                       | 156 ++++----
 api_guides/python/python_io.md                |   8 +-
 api_guides/python/reading_data.md             |  84 ++---
 api_guides/python/regression_examples.md      |  14 +-
 api_guides/python/session_ops.md              |   8 +-
 api_guides/python/sparse_ops.md               |  44 +--
 api_guides/python/spectral_ops.md             |  29 +-
 api_guides/python/state_ops.md                | 122 +++----
 api_guides/python/string_ops.md               |  28 +-
 api_guides/python/summary.md                  |  22 +-
 api_guides/python/test.md                     |  20 +-
 api_guides/python/tfdbg.md                    |  22 +-
 api_guides/python/threading_and_queues.md     |  38 +-
 api_guides/python/train.md                    | 147 ++++----
 api_guides/python/upgrade.md                  | 334 ++++++++++++++++++
 47 files changed, 1544 insertions(+), 1363 deletions(-)
 delete mode 100644 api_guides/python/contrib.bayesflow.monte_carlo.md
 delete mode 100644 api_guides/python/contrib.distributions.bijectors.md
 delete mode 100644 api_guides/python/contrib.distributions.md
 create mode 100644 api_guides/python/upgrade.md

diff --git a/api_guides/cc/guide.md b/api_guides/cc/guide.md
index 4e51ada..d9b660b 100644
--- a/api_guides/cc/guide.md
+++ b/api_guides/cc/guide.md
@@ -7,6 +7,12 @@ You should, as a result, be sure you are following the
 [`master` version of this doc](https://www.tensorflow.org/versions/master/api_guides/cc/guide),
 in case there have been any changes.
 
+Note: The C++ API is only designed to work with TensorFlow `bazel build`.
+If you need a stand-alone option use the [C-api](../../install/lang_c.md).
+See [these instructions](https://docs.bazel.build/versions/master/external.html)
+for details on how to include TensorFlow as a subproject (instead of building
+your project from inside TensorFlow, as in this example).
+
 [TOC]
 
 TensorFlow's C++ API provides mechanisms for constructing and executing a data
@@ -92,7 +98,7 @@ We will delve into the details of each below.
 
 ### Scope
 
-@{tensorflow::Scope} is the main data structure that holds the current state
+`tensorflow::Scope` is the main data structure that holds the current state
 of graph construction. A `Scope` acts as a handle to the graph being
 constructed, as well as storing TensorFlow operation properties. The `Scope`
 object is the first argument to operation constructors, and operations that use
@@ -102,7 +108,7 @@ explained further below.
 
 Create a new `Scope` object by calling `Scope::NewRootScope`. This creates
 some resources such as a graph to which operations are added. It also creates a
-@{tensorflow::Status} object which will be used to indicate errors encountered
+`tensorflow::Status` object which will be used to indicate errors encountered
 when constructing operations. The `Scope` class has value semantics, thus, a
 `Scope` object can be freely copied and passed around.
 
@@ -121,7 +127,7 @@ Here are some of the properties controlled by a `Scope` object:
 * Device placement for an operation
 * Kernel attribute for an operation
 
-Please refer to @{tensorflow::Scope} for the complete list of member functions
+Please refer to `tensorflow::Scope` for the complete list of member functions
 that let you create child scopes with new properties.
 
 ### Operation Constructors
@@ -213,7 +219,7 @@ auto c = Concat(scope, s, 0);
 
 You may pass many different types of C++ values directly to tensor
 constants. You may explicitly create a tensor constant by calling the
-@{tensorflow::ops::Const} function from various kinds of C++ values. For
+`tensorflow::ops::Const` function from various kinds of C++ values. For
 example:
 
 * Scalars
@@ -257,14 +263,14 @@ auto y = Add(scope, {1, 2, 3, 4}, 10);
 ## Graph Execution
 
 When executing a graph, you will need a session. The C++ API provides a
-@{tensorflow::ClientSession} class that will execute ops created by the
+`tensorflow::ClientSession` class that will execute ops created by the
 operation constructors. TensorFlow will automatically determine which parts of
 the graph need to be executed, and what values need feeding. For example:
 
 ```c++
 Scope root = Scope::NewRootScope();
 auto c = Const(root, { {1, 1} });
-auto m = MatMul(root, c, { {42}, {1} });
+auto m = MatMul(root, c, { {41}, {1} });
 
 ClientSession session(root);
 std::vector<Tensor> outputs;
@@ -291,5 +297,5 @@ session.Run({ {a, { {1, 2}, {3, 4} } } }, {c}, &outputs);
 // outputs[0] == [4 5; 6 7]
 ```
 
-Please see the @{tensorflow::Tensor} documentation for more information on how
+Please see the `tensorflow::Tensor` documentation for more information on how
 to use the execution output.
diff --git a/api_guides/python/array_ops.md b/api_guides/python/array_ops.md
index a34f01f..ddeea80 100644
--- a/api_guides/python/array_ops.md
+++ b/api_guides/python/array_ops.md
@@ -1,7 +1,7 @@
 # Tensor Transformations
 
 Note: Functions taking `Tensor` arguments can also take anything accepted by
-@{tf.convert_to_tensor}.
+`tf.convert_to_tensor`.
 
 [TOC]
 
@@ -10,78 +10,78 @@ Note: Functions taking `Tensor` arguments can also take anything accepted by
 TensorFlow provides several operations that you can use to cast tensor data
 types in your graph.
 
-*   @{tf.string_to_number}
-*   @{tf.to_double}
-*   @{tf.to_float}
-*   @{tf.to_bfloat16}
-*   @{tf.to_int32}
-*   @{tf.to_int64}
-*   @{tf.cast}
-*   @{tf.bitcast}
-*   @{tf.saturate_cast}
+*   `tf.string_to_number`
+*   `tf.to_double`
+*   `tf.to_float`
+*   `tf.to_bfloat16`
+*   `tf.to_int32`
+*   `tf.to_int64`
+*   `tf.cast`
+*   `tf.bitcast`
+*   `tf.saturate_cast`
 
 ## Shapes and Shaping
 
 TensorFlow provides several operations that you can use to determine the shape
 of a tensor and change the shape of a tensor.
 
-*   @{tf.broadcast_dynamic_shape}
-*   @{tf.broadcast_static_shape}
-*   @{tf.shape}
-*   @{tf.shape_n}
-*   @{tf.size}
-*   @{tf.rank}
-*   @{tf.reshape}
-*   @{tf.squeeze}
-*   @{tf.expand_dims}
-*   @{tf.meshgrid}
+*   `tf.broadcast_dynamic_shape`
+*   `tf.broadcast_static_shape`
+*   `tf.shape`
+*   `tf.shape_n`
+*   `tf.size`
+*   `tf.rank`
+*   `tf.reshape`
+*   `tf.squeeze`
+*   `tf.expand_dims`
+*   `tf.meshgrid`
 
 ## Slicing and Joining
 
 TensorFlow provides several operations to slice or extract parts of a tensor,
 or join multiple tensors together.
 
-*   @{tf.slice}
-*   @{tf.strided_slice}
-*   @{tf.split}
-*   @{tf.tile}
-*   @{tf.pad}
-*   @{tf.concat}
-*   @{tf.stack}
-*   @{tf.parallel_stack}
-*   @{tf.unstack}
-*   @{tf.reverse_sequence}
-*   @{tf.reverse}
-*   @{tf.reverse_v2}
-*   @{tf.transpose}
-*   @{tf.extract_image_patches}
-*   @{tf.space_to_batch_nd}
-*   @{tf.space_to_batch}
-*   @{tf.required_space_to_batch_paddings}
-*   @{tf.batch_to_space_nd}
-*   @{tf.batch_to_space}
-*   @{tf.space_to_depth}
-*   @{tf.depth_to_space}
-*   @{tf.gather}
-*   @{tf.gather_nd}
-*   @{tf.unique_with_counts}
-*   @{tf.scatter_nd}
-*   @{tf.dynamic_partition}
-*   @{tf.dynamic_stitch}
-*   @{tf.boolean_mask}
-*   @{tf.one_hot}
-*   @{tf.sequence_mask}
-*   @{tf.dequantize}
-*   @{tf.quantize_v2}
-*   @{tf.quantized_concat}
-*   @{tf.setdiff1d}
+*   `tf.slice`
+*   `tf.strided_slice`
+*   `tf.split`
+*   `tf.tile`
+*   `tf.pad`
+*   `tf.concat`
+*   `tf.stack`
+*   `tf.parallel_stack`
+*   `tf.unstack`
+*   `tf.reverse_sequence`
+*   `tf.reverse`
+*   `tf.reverse_v2`
+*   `tf.transpose`
+*   `tf.extract_image_patches`
+*   `tf.space_to_batch_nd`
+*   `tf.space_to_batch`
+*   `tf.required_space_to_batch_paddings`
+*   `tf.batch_to_space_nd`
+*   `tf.batch_to_space`
+*   `tf.space_to_depth`
+*   `tf.depth_to_space`
+*   `tf.gather`
+*   `tf.gather_nd`
+*   `tf.unique_with_counts`
+*   `tf.scatter_nd`
+*   `tf.dynamic_partition`
+*   `tf.dynamic_stitch`
+*   `tf.boolean_mask`
+*   `tf.one_hot`
+*   `tf.sequence_mask`
+*   `tf.dequantize`
+*   `tf.quantize_v2`
+*   `tf.quantized_concat`
+*   `tf.setdiff1d`
 
 ## Fake quantization
 Operations used to help train for better quantization accuracy.
 
-*   @{tf.fake_quant_with_min_max_args}
-*   @{tf.fake_quant_with_min_max_args_gradient}
-*   @{tf.fake_quant_with_min_max_vars}
-*   @{tf.fake_quant_with_min_max_vars_gradient}
-*   @{tf.fake_quant_with_min_max_vars_per_channel}
-*   @{tf.fake_quant_with_min_max_vars_per_channel_gradient}
+*   `tf.fake_quant_with_min_max_args`
+*   `tf.fake_quant_with_min_max_args_gradient`
+*   `tf.fake_quant_with_min_max_vars`
+*   `tf.fake_quant_with_min_max_vars_gradient`
+*   `tf.fake_quant_with_min_max_vars_per_channel`
+*   `tf.fake_quant_with_min_max_vars_per_channel_gradient`
diff --git a/api_guides/python/check_ops.md b/api_guides/python/check_ops.md
index 6f8a18a..b52fdaa 100644
--- a/api_guides/python/check_ops.md
+++ b/api_guides/python/check_ops.md
@@ -1,19 +1,19 @@
 # Asserts and boolean checks
 
-*   @{tf.assert_negative}
-*   @{tf.assert_positive}
-*   @{tf.assert_proper_iterable}
-*   @{tf.assert_non_negative}
-*   @{tf.assert_non_positive}
-*   @{tf.assert_equal}
-*   @{tf.assert_integer}
-*   @{tf.assert_less}
-*   @{tf.assert_less_equal}
-*   @{tf.assert_greater}
-*   @{tf.assert_greater_equal}
-*   @{tf.assert_rank}
-*   @{tf.assert_rank_at_least}
-*   @{tf.assert_type}
-*   @{tf.is_non_decreasing}
-*   @{tf.is_numeric_tensor}
-*   @{tf.is_strictly_increasing}
+*   `tf.assert_negative`
+*   `tf.assert_positive`
+*   `tf.assert_proper_iterable`
+*   `tf.assert_non_negative`
+*   `tf.assert_non_positive`
+*   `tf.assert_equal`
+*   `tf.assert_integer`
+*   `tf.assert_less`
+*   `tf.assert_less_equal`
+*   `tf.assert_greater`
+*   `tf.assert_greater_equal`
+*   `tf.assert_rank`
+*   `tf.assert_rank_at_least`
+*   `tf.assert_type`
+*   `tf.is_non_decreasing`
+*   `tf.is_numeric_tensor`
+*   `tf.is_strictly_increasing`
diff --git a/api_guides/python/client.md b/api_guides/python/client.md
index eef2369..fdd48e6 100644
--- a/api_guides/python/client.md
+++ b/api_guides/python/client.md
@@ -3,34 +3,34 @@
 
 This library contains classes for launching graphs and executing operations.
 
-@{$programmers_guide/low_level_intro$This guide} has examples of how a graph
-is launched in a @{tf.Session}.
+[This guide](../../guide/low_level_intro.md) has examples of how a graph
+is launched in a `tf.Session`.
 
 ## Session management
 
-*   @{tf.Session}
-*   @{tf.InteractiveSession}
-*   @{tf.get_default_session}
+*   `tf.Session`
+*   `tf.InteractiveSession`
+*   `tf.get_default_session`
 
 ## Error classes and convenience functions
 
-*   @{tf.OpError}
-*   @{tf.errors.CancelledError}
-*   @{tf.errors.UnknownError}
-*   @{tf.errors.InvalidArgumentError}
-*   @{tf.errors.DeadlineExceededError}
-*   @{tf.errors.NotFoundError}
-*   @{tf.errors.AlreadyExistsError}
-*   @{tf.errors.PermissionDeniedError}
-*   @{tf.errors.UnauthenticatedError}
-*   @{tf.errors.ResourceExhaustedError}
-*   @{tf.errors.FailedPreconditionError}
-*   @{tf.errors.AbortedError}
-*   @{tf.errors.OutOfRangeError}
-*   @{tf.errors.UnimplementedError}
-*   @{tf.errors.InternalError}
-*   @{tf.errors.UnavailableError}
-*   @{tf.errors.DataLossError}
-*   @{tf.errors.exception_type_from_error_code}
-*   @{tf.errors.error_code_from_exception_type}
-*   @{tf.errors.raise_exception_on_not_ok_status}
+*   `tf.OpError`
+*   `tf.errors.CancelledError`
+*   `tf.errors.UnknownError`
+*   `tf.errors.InvalidArgumentError`
+*   `tf.errors.DeadlineExceededError`
+*   `tf.errors.NotFoundError`
+*   `tf.errors.AlreadyExistsError`
+*   `tf.errors.PermissionDeniedError`
+*   `tf.errors.UnauthenticatedError`
+*   `tf.errors.ResourceExhaustedError`
+*   `tf.errors.FailedPreconditionError`
+*   `tf.errors.AbortedError`
+*   `tf.errors.OutOfRangeError`
+*   `tf.errors.UnimplementedError`
+*   `tf.errors.InternalError`
+*   `tf.errors.UnavailableError`
+*   `tf.errors.DataLossError`
+*   `tf.errors.exception_type_from_error_code`
+*   `tf.errors.error_code_from_exception_type`
+*   `tf.errors.raise_exception_on_not_ok_status`
diff --git a/api_guides/python/constant_op.md b/api_guides/python/constant_op.md
index db3410c..9ba95b0 100644
--- a/api_guides/python/constant_op.md
+++ b/api_guides/python/constant_op.md
@@ -1,7 +1,7 @@
 # Constants, Sequences, and Random Values
 
 Note: Functions taking `Tensor` arguments can also take anything accepted by
-@{tf.convert_to_tensor}.
+`tf.convert_to_tensor`.
 
 [TOC]
 
@@ -9,17 +9,17 @@ Note: Functions taking `Tensor` arguments can also take anything accepted by
 
 TensorFlow provides several operations that you can use to generate constants.
 
-*   @{tf.zeros}
-*   @{tf.zeros_like}
-*   @{tf.ones}
-*   @{tf.ones_like}
-*   @{tf.fill}
-*   @{tf.constant}
+*   `tf.zeros`
+*   `tf.zeros_like`
+*   `tf.ones`
+*   `tf.ones_like`
+*   `tf.fill`
+*   `tf.constant`
 
 ## Sequences
 
-*   @{tf.linspace}
-*   @{tf.range}
+*   `tf.linspace`
+*   `tf.range`
 
 ## Random Tensors
 
@@ -29,11 +29,11 @@ time they are evaluated.
 
 The `seed` keyword argument in these functions acts in conjunction with
 the graph-level random seed. Changing either the graph-level seed using
-@{tf.set_random_seed} or the
+`tf.set_random_seed` or the
 op-level seed will change the underlying seed of these operations. Setting
 neither graph-level nor op-level seed, results in a random seed for all
 operations.
-See @{tf.set_random_seed}
+See `tf.set_random_seed`
 for details on the interaction between operation-level and graph-level random
 seeds.
 
@@ -64,7 +64,7 @@ print(sess.run(norm))
 ```
 
 Another common use of random values is the initialization of variables. Also see
-the @{$variables$Variables How To}.
+the [Variables How To](../../guide/variables.md).
 
 ```python
 # Use random uniform values in [0, 1) as the initializer for a variable of shape
@@ -77,11 +77,11 @@ sess.run(init)
 print(sess.run(var))
 ```
 
-*   @{tf.random_normal}
-*   @{tf.truncated_normal}
-*   @{tf.random_uniform}
-*   @{tf.random_shuffle}
-*   @{tf.random_crop}
-*   @{tf.multinomial}
-*   @{tf.random_gamma}
-*   @{tf.set_random_seed}
+*   `tf.random_normal`
+*   `tf.truncated_normal`
+*   `tf.random_uniform`
+*   `tf.random_shuffle`
+*   `tf.random_crop`
+*   `tf.multinomial`
+*   `tf.random_gamma`
+*   `tf.set_random_seed`
diff --git a/api_guides/python/contrib.bayesflow.monte_carlo.md b/api_guides/python/contrib.bayesflow.monte_carlo.md
deleted file mode 100644
index f3db585..0000000
--- a/api_guides/python/contrib.bayesflow.monte_carlo.md
+++ /dev/null
@@ -1,54 +0,0 @@
-# BayesFlow Monte Carlo (contrib)
-[TOC]
-
-Monte Carlo integration and helpers.
-
-## Background
-
-Monte Carlo integration refers to the practice of estimating an expectation with
-a sample mean.  For example, given random variable `Z in \\(R^k\\)` with density `p`,
-the expectation of function `f` can be approximated like:
-
-```
-$$E_p[f(Z)] = \int f(z) p(z) dz$$
-$$          ~ S_n
-          := n^{-1} \sum_{i=1}^n f(z_i),  z_i\ iid\ samples\ from\ p.$$
-```
-
-If `\\(E_p[|f(Z)|] < infinity\\)`, then `\\(S_n\\) --> \\(E_p[f(Z)]\\)` by the strong law of large
-numbers.  If `\\(E_p[f(Z)^2] < infinity\\)`, then `\\(S_n\\)` is asymptotically normal with
-variance `\\(Var[f(Z)] / n\\)`.
-
-Practitioners of Bayesian statistics often find themselves wanting to estimate
-`\\(E_p[f(Z)]\\)` when the distribution `p` is known only up to a constant.  For
-example, the joint distribution `p(z, x)` may be known, but the evidence
-`\\(p(x) = \int p(z, x) dz\\)` may be intractable.  In that case, a parameterized
-distribution family `\\(q_\lambda(z)\\)` may be chosen, and the optimal `\\(\lambda\\)` is the
-one minimizing the KL divergence between `\\(q_\lambda(z)\\)` and
-`\\(p(z | x)\\)`.  We only know `p(z, x)`, but that is sufficient to find `\\(\lambda\\)`.
-
-
-## Log-space evaluation and subtracting the maximum
-
-Care must be taken when the random variable lives in a high dimensional space.
-For example, the naive importance sample estimate `\\(E_q[f(Z) p(Z) / q(Z)]\\)`
-involves the ratio of two terms `\\(p(Z) / q(Z)\\)`, each of which must have tails
-dropping off faster than `\\(O(|z|^{-(k + 1)})\\)` in order to have finite integral.
-This ratio would often be zero or infinity up to numerical precision.
-
-For that reason, we write
-
-```
-$$Log E_q[ f(Z) p(Z) / q(Z) ]$$
-$$   = Log E_q[ \exp\{Log[f(Z)] + Log[p(Z)] - Log[q(Z)] - C\} ] + C,$$  where
-$$C := Max[ Log[f(Z)] + Log[p(Z)] - Log[q(Z)] ].$$
-```
-
-The maximum value of the exponentiated term will be 0.0, and the expectation
-can be evaluated in a stable manner.
-
-## Ops
-
-*   @{tf.contrib.bayesflow.monte_carlo.expectation}
-*   @{tf.contrib.bayesflow.monte_carlo.expectation_importance_sampler}
-*   @{tf.contrib.bayesflow.monte_carlo.expectation_importance_sampler_logspace}
diff --git a/api_guides/python/contrib.crf.md b/api_guides/python/contrib.crf.md
index 428383f..a544f13 100644
--- a/api_guides/python/contrib.crf.md
+++ b/api_guides/python/contrib.crf.md
@@ -2,10 +2,10 @@
 
 Linear-chain CRF layer.
 
-*   @{tf.contrib.crf.crf_sequence_score}
-*   @{tf.contrib.crf.crf_log_norm}
-*   @{tf.contrib.crf.crf_log_likelihood}
-*   @{tf.contrib.crf.crf_unary_score}
-*   @{tf.contrib.crf.crf_binary_score}
-*   @{tf.contrib.crf.CrfForwardRnnCell}
-*   @{tf.contrib.crf.viterbi_decode}
+*   `tf.contrib.crf.crf_sequence_score`
+*   `tf.contrib.crf.crf_log_norm`
+*   `tf.contrib.crf.crf_log_likelihood`
+*   `tf.contrib.crf.crf_unary_score`
+*   `tf.contrib.crf.crf_binary_score`
+*   `tf.contrib.crf.CrfForwardRnnCell`
+*   `tf.contrib.crf.viterbi_decode`
diff --git a/api_guides/python/contrib.distributions.bijectors.md b/api_guides/python/contrib.distributions.bijectors.md
deleted file mode 100644
index e169897..0000000
--- a/api_guides/python/contrib.distributions.bijectors.md
+++ /dev/null
@@ -1,32 +0,0 @@
-# Random variable transformations (contrib)
-[TOC]
-
-Bijector Ops.
-
-An API for invertible, differentiable transformations of random variables.
-
-## Background
-
-Differentiable, bijective transformations of continuous random variables alter
-the calculations made in the cumulative/probability distribution functions and
-sample function.  This module provides a standard interface for making these
-manipulations.
-
-For more details and examples, see the `Bijector` docstring.
-
-To apply a `Bijector`, use `distributions.TransformedDistribution`.
-
-## Bijectors
-
-*   @{tf.contrib.distributions.bijectors.Affine}
-*   @{tf.contrib.distributions.bijectors.AffineLinearOperator}
-*   @{tf.contrib.distributions.bijectors.Bijector}
-*   @{tf.contrib.distributions.bijectors.Chain}
-*   @{tf.contrib.distributions.bijectors.CholeskyOuterProduct}
-*   @{tf.contrib.distributions.bijectors.Exp}
-*   @{tf.contrib.distributions.bijectors.Identity}
-*   @{tf.contrib.distributions.bijectors.Inline}
-*   @{tf.contrib.distributions.bijectors.Invert}
-*   @{tf.contrib.distributions.bijectors.PowerTransform}
-*   @{tf.contrib.distributions.bijectors.SoftmaxCentered}
-*   @{tf.contrib.distributions.bijectors.Softplus}
diff --git a/api_guides/python/contrib.distributions.md b/api_guides/python/contrib.distributions.md
deleted file mode 100644
index 533d7da..0000000
--- a/api_guides/python/contrib.distributions.md
+++ /dev/null
@@ -1,83 +0,0 @@
-# Statistical Distributions (contrib)
-[TOC]
-
-Classes representing statistical distributions and ops for working with them.
-
-## Classes for statistical distributions
-
-Classes that represent batches of statistical distributions.  Each class is
-initialized with parameters that define the distributions.
-
-## Base classes
-
-*   @{tf.contrib.distributions.ReparameterizationType}
-*   @{tf.contrib.distributions.Distribution}
-
-## Univariate (scalar) distributions
-
-*   @{tf.contrib.distributions.Binomial}
-*   @{tf.contrib.distributions.Bernoulli}
-*   @{tf.contrib.distributions.Beta}
-*   @{tf.contrib.distributions.Categorical}
-*   @{tf.contrib.distributions.Chi2}
-*   @{tf.contrib.distributions.Chi2WithAbsDf}
-*   @{tf.contrib.distributions.Exponential}
-*   @{tf.contrib.distributions.Gamma}
-*   @{tf.contrib.distributions.InverseGamma}
-*   @{tf.contrib.distributions.Laplace}
-*   @{tf.contrib.distributions.LaplaceWithSoftplusScale}
-*   @{tf.contrib.distributions.Normal}
-*   @{tf.contrib.distributions.NormalWithSoftplusScale}
-*   @{tf.contrib.distributions.Poisson}
-*   @{tf.contrib.distributions.StudentT}
-*   @{tf.contrib.distributions.StudentTWithAbsDfSoftplusScale}
-*   @{tf.contrib.distributions.Uniform}
-
-## Multivariate distributions
-
-### Multivariate normal
-
-*   @{tf.contrib.distributions.MultivariateNormalDiag}
-*   @{tf.contrib.distributions.MultivariateNormalTriL}
-*   @{tf.contrib.distributions.MultivariateNormalDiagPlusLowRank}
-*   @{tf.contrib.distributions.MultivariateNormalDiagWithSoftplusScale}
-
-### Other multivariate distributions
-
-*   @{tf.contrib.distributions.Dirichlet}
-*   @{tf.contrib.distributions.DirichletMultinomial}
-*   @{tf.contrib.distributions.Multinomial}
-*   @{tf.contrib.distributions.WishartCholesky}
-*   @{tf.contrib.distributions.WishartFull}
-
-### Multivariate Utilities
-
-*   @{tf.contrib.distributions.matrix_diag_transform}
-
-## Transformed distributions
-
-*   @{tf.contrib.distributions.TransformedDistribution}
-*   @{tf.contrib.distributions.QuantizedDistribution}
-
-## Mixture Models
-
-*   @{tf.contrib.distributions.Mixture}
-
-## Posterior inference with conjugate priors
-
-Functions that transform conjugate prior/likelihood pairs to distributions
-representing the posterior or posterior predictive.
-
-## Normal likelihood with conjugate prior
-
-*   @{tf.contrib.distributions.normal_conjugates_known_scale_posterior}
-*   @{tf.contrib.distributions.normal_conjugates_known_scale_predictive}
-
-## Kullback-Leibler Divergence
-
-*   @{tf.contrib.distributions.kl_divergence}
-*   @{tf.contrib.distributions.RegisterKL}
-
-## Utilities
-
-*   @{tf.contrib.distributions.softplus_inverse}
diff --git a/api_guides/python/contrib.ffmpeg.md b/api_guides/python/contrib.ffmpeg.md
index 2794868..7df7547 100644
--- a/api_guides/python/contrib.ffmpeg.md
+++ b/api_guides/python/contrib.ffmpeg.md
@@ -19,5 +19,5 @@ uncompressed_binary = ffmpeg.encode_audio(
     waveform, file_format='wav', samples_per_second=44100)
 ```
 
-*   @{tf.contrib.ffmpeg.decode_audio}
-*   @{tf.contrib.ffmpeg.encode_audio}
+*   `tf.contrib.ffmpeg.decode_audio`
+*   `tf.contrib.ffmpeg.encode_audio`
diff --git a/api_guides/python/contrib.framework.md b/api_guides/python/contrib.framework.md
index f7f26e5..00fb8b0 100644
--- a/api_guides/python/contrib.framework.md
+++ b/api_guides/python/contrib.framework.md
@@ -3,59 +3,62 @@
 
 Framework utilities.
 
-*   @{tf.contrib.framework.assert_same_float_dtype}
-*   @{tf.contrib.framework.assert_scalar}
-*   @{tf.contrib.framework.assert_scalar_int}
-*   @{tf.convert_to_tensor_or_sparse_tensor}
-*   @{tf.contrib.framework.get_graph_from_inputs}
-*   @{tf.is_numeric_tensor}
-*   @{tf.is_non_decreasing}
-*   @{tf.is_strictly_increasing}
-*   @{tf.contrib.framework.is_tensor}
-*   @{tf.contrib.framework.reduce_sum_n}
-*   @{tf.contrib.framework.remove_squeezable_dimensions}
-*   @{tf.contrib.framework.with_shape}
-*   @{tf.contrib.framework.with_same_shape}
+*   `tf.contrib.framework.assert_same_float_dtype`
+*   `tf.contrib.framework.assert_scalar`
+*   `tf.contrib.framework.assert_scalar_int`
+*   `tf.convert_to_tensor_or_sparse_tensor`
+*   `tf.contrib.framework.get_graph_from_inputs`
+*   `tf.is_numeric_tensor`
+*   `tf.is_non_decreasing`
+*   `tf.is_strictly_increasing`
+*   `tf.contrib.framework.is_tensor`
+*   `tf.contrib.framework.reduce_sum_n`
+*   `tf.contrib.framework.remove_squeezable_dimensions`
+*   `tf.contrib.framework.with_shape`
+*   `tf.contrib.framework.with_same_shape`
 
 ## Deprecation
-*   @{tf.contrib.framework.deprecated}
-*   @{tf.contrib.framework.deprecated_args}
-*   @{tf.contrib.framework.deprecated_arg_values}
+
+*   `tf.contrib.framework.deprecated`
+*   `tf.contrib.framework.deprecated_args`
+*   `tf.contrib.framework.deprecated_arg_values`
 
 ## Arg_Scope
-*   @{tf.contrib.framework.arg_scope}
-*   @{tf.contrib.framework.add_arg_scope}
-*   @{tf.contrib.framework.has_arg_scope}
-*   @{tf.contrib.framework.arg_scoped_arguments}
+
+*   `tf.contrib.framework.arg_scope`
+*   `tf.contrib.framework.add_arg_scope`
+*   `tf.contrib.framework.has_arg_scope`
+*   `tf.contrib.framework.arg_scoped_arguments`
 
 ## Variables
-*   @{tf.contrib.framework.add_model_variable}
-*   @{tf.train.assert_global_step}
-*   @{tf.contrib.framework.assert_or_get_global_step}
-*   @{tf.contrib.framework.assign_from_checkpoint}
-*   @{tf.contrib.framework.assign_from_checkpoint_fn}
-*   @{tf.contrib.framework.assign_from_values}
-*   @{tf.contrib.framework.assign_from_values_fn}
-*   @{tf.contrib.framework.create_global_step}
-*   @{tf.contrib.framework.filter_variables}
-*   @{tf.train.get_global_step}
-*   @{tf.contrib.framework.get_or_create_global_step}
-*   @{tf.contrib.framework.get_local_variables}
-*   @{tf.contrib.framework.get_model_variables}
-*   @{tf.contrib.framework.get_unique_variable}
-*   @{tf.contrib.framework.get_variables_by_name}
-*   @{tf.contrib.framework.get_variables_by_suffix}
-*   @{tf.contrib.framework.get_variables_to_restore}
-*   @{tf.contrib.framework.get_variables}
-*   @{tf.contrib.framework.local_variable}
-*   @{tf.contrib.framework.model_variable}
-*   @{tf.contrib.framework.variable}
-*   @{tf.contrib.framework.VariableDeviceChooser}
-*   @{tf.contrib.framework.zero_initializer}
+
+*   `tf.contrib.framework.add_model_variable`
+*   `tf.train.assert_global_step`
+*   `tf.contrib.framework.assert_or_get_global_step`
+*   `tf.contrib.framework.assign_from_checkpoint`
+*   `tf.contrib.framework.assign_from_checkpoint_fn`
+*   `tf.contrib.framework.assign_from_values`
+*   `tf.contrib.framework.assign_from_values_fn`
+*   `tf.contrib.framework.create_global_step`
+*   `tf.contrib.framework.filter_variables`
+*   `tf.train.get_global_step`
+*   `tf.contrib.framework.get_or_create_global_step`
+*   `tf.contrib.framework.get_local_variables`
+*   `tf.contrib.framework.get_model_variables`
+*   `tf.contrib.framework.get_unique_variable`
+*   `tf.contrib.framework.get_variables_by_name`
+*   `tf.contrib.framework.get_variables_by_suffix`
+*   `tf.contrib.framework.get_variables_to_restore`
+*   `tf.contrib.framework.get_variables`
+*   `tf.contrib.framework.local_variable`
+*   `tf.contrib.framework.model_variable`
+*   `tf.contrib.framework.variable`
+*   `tf.contrib.framework.VariableDeviceChooser`
+*   `tf.contrib.framework.zero_initializer`
 
 ## Checkpoint utilities
 
-*   @{tf.contrib.framework.load_checkpoint}
-*   @{tf.contrib.framework.list_variables}
-*   @{tf.contrib.framework.load_variable}
-*   @{tf.contrib.framework.init_from_checkpoint}
+*   `tf.contrib.framework.load_checkpoint`
+*   `tf.contrib.framework.list_variables`
+*   `tf.contrib.framework.load_variable`
+*   `tf.contrib.framework.init_from_checkpoint`
diff --git a/api_guides/python/contrib.graph_editor.md b/api_guides/python/contrib.graph_editor.md
index 20fe88a..8ce49b9 100644
--- a/api_guides/python/contrib.graph_editor.md
+++ b/api_guides/python/contrib.graph_editor.md
@@ -100,78 +100,78 @@ which to operate must always be given explicitly. This is the reason why
 
 ## Module: util
 
-*   @{tf.contrib.graph_editor.make_list_of_op}
-*   @{tf.contrib.graph_editor.get_tensors}
-*   @{tf.contrib.graph_editor.make_list_of_t}
-*   @{tf.contrib.graph_editor.get_generating_ops}
-*   @{tf.contrib.graph_editor.get_consuming_ops}
-*   @{tf.contrib.graph_editor.ControlOutputs}
-*   @{tf.contrib.graph_editor.placeholder_name}
-*   @{tf.contrib.graph_editor.make_placeholder_from_tensor}
-*   @{tf.contrib.graph_editor.make_placeholder_from_dtype_and_shape}
+*   `tf.contrib.graph_editor.make_list_of_op`
+*   `tf.contrib.graph_editor.get_tensors`
+*   `tf.contrib.graph_editor.make_list_of_t`
+*   `tf.contrib.graph_editor.get_generating_ops`
+*   `tf.contrib.graph_editor.get_consuming_ops`
+*   `tf.contrib.graph_editor.ControlOutputs`
+*   `tf.contrib.graph_editor.placeholder_name`
+*   `tf.contrib.graph_editor.make_placeholder_from_tensor`
+*   `tf.contrib.graph_editor.make_placeholder_from_dtype_and_shape`
 
 ## Module: select
 
-*   @{tf.contrib.graph_editor.filter_ts}
-*   @{tf.contrib.graph_editor.filter_ts_from_regex}
-*   @{tf.contrib.graph_editor.filter_ops}
-*   @{tf.contrib.graph_editor.filter_ops_from_regex}
-*   @{tf.contrib.graph_editor.get_name_scope_ops}
-*   @{tf.contrib.graph_editor.check_cios}
-*   @{tf.contrib.graph_editor.get_ops_ios}
-*   @{tf.contrib.graph_editor.compute_boundary_ts}
-*   @{tf.contrib.graph_editor.get_within_boundary_ops}
-*   @{tf.contrib.graph_editor.get_forward_walk_ops}
-*   @{tf.contrib.graph_editor.get_backward_walk_ops}
-*   @{tf.contrib.graph_editor.get_walks_intersection_ops}
-*   @{tf.contrib.graph_editor.get_walks_union_ops}
-*   @{tf.contrib.graph_editor.select_ops}
-*   @{tf.contrib.graph_editor.select_ts}
-*   @{tf.contrib.graph_editor.select_ops_and_ts}
+*   `tf.contrib.graph_editor.filter_ts`
+*   `tf.contrib.graph_editor.filter_ts_from_regex`
+*   `tf.contrib.graph_editor.filter_ops`
+*   `tf.contrib.graph_editor.filter_ops_from_regex`
+*   `tf.contrib.graph_editor.get_name_scope_ops`
+*   `tf.contrib.graph_editor.check_cios`
+*   `tf.contrib.graph_editor.get_ops_ios`
+*   `tf.contrib.graph_editor.compute_boundary_ts`
+*   `tf.contrib.graph_editor.get_within_boundary_ops`
+*   `tf.contrib.graph_editor.get_forward_walk_ops`
+*   `tf.contrib.graph_editor.get_backward_walk_ops`
+*   `tf.contrib.graph_editor.get_walks_intersection_ops`
+*   `tf.contrib.graph_editor.get_walks_union_ops`
+*   `tf.contrib.graph_editor.select_ops`
+*   `tf.contrib.graph_editor.select_ts`
+*   `tf.contrib.graph_editor.select_ops_and_ts`
 
 ## Module: subgraph
 
-*   @{tf.contrib.graph_editor.SubGraphView}
-*   @{tf.contrib.graph_editor.make_view}
-*   @{tf.contrib.graph_editor.make_view_from_scope}
+*   `tf.contrib.graph_editor.SubGraphView`
+*   `tf.contrib.graph_editor.make_view`
+*   `tf.contrib.graph_editor.make_view_from_scope`
 
 ## Module: reroute
 
-*   @{tf.contrib.graph_editor.swap_ts}
-*   @{tf.contrib.graph_editor.reroute_ts}
-*   @{tf.contrib.graph_editor.swap_inputs}
-*   @{tf.contrib.graph_editor.reroute_inputs}
-*   @{tf.contrib.graph_editor.swap_outputs}
-*   @{tf.contrib.graph_editor.reroute_outputs}
-*   @{tf.contrib.graph_editor.swap_ios}
-*   @{tf.contrib.graph_editor.reroute_ios}
-*   @{tf.contrib.graph_editor.remove_control_inputs}
-*   @{tf.contrib.graph_editor.add_control_inputs}
+*   `tf.contrib.graph_editor.swap_ts`
+*   `tf.contrib.graph_editor.reroute_ts`
+*   `tf.contrib.graph_editor.swap_inputs`
+*   `tf.contrib.graph_editor.reroute_inputs`
+*   `tf.contrib.graph_editor.swap_outputs`
+*   `tf.contrib.graph_editor.reroute_outputs`
+*   `tf.contrib.graph_editor.swap_ios`
+*   `tf.contrib.graph_editor.reroute_ios`
+*   `tf.contrib.graph_editor.remove_control_inputs`
+*   `tf.contrib.graph_editor.add_control_inputs`
 
 ## Module: edit
 
-*   @{tf.contrib.graph_editor.detach_control_inputs}
-*   @{tf.contrib.graph_editor.detach_control_outputs}
-*   @{tf.contrib.graph_editor.detach_inputs}
-*   @{tf.contrib.graph_editor.detach_outputs}
-*   @{tf.contrib.graph_editor.detach}
-*   @{tf.contrib.graph_editor.connect}
-*   @{tf.contrib.graph_editor.bypass}
+*   `tf.contrib.graph_editor.detach_control_inputs`
+*   `tf.contrib.graph_editor.detach_control_outputs`
+*   `tf.contrib.graph_editor.detach_inputs`
+*   `tf.contrib.graph_editor.detach_outputs`
+*   `tf.contrib.graph_editor.detach`
+*   `tf.contrib.graph_editor.connect`
+*   `tf.contrib.graph_editor.bypass`
 
 ## Module: transform
 
-*   @{tf.contrib.graph_editor.replace_t_with_placeholder_handler}
-*   @{tf.contrib.graph_editor.keep_t_if_possible_handler}
-*   @{tf.contrib.graph_editor.assign_renamed_collections_handler}
-*   @{tf.contrib.graph_editor.transform_op_if_inside_handler}
-*   @{tf.contrib.graph_editor.copy_op_handler}
-*   @{tf.contrib.graph_editor.Transformer}
-*   @{tf.contrib.graph_editor.copy}
-*   @{tf.contrib.graph_editor.copy_with_input_replacements}
-*   @{tf.contrib.graph_editor.graph_replace}
+*   `tf.contrib.graph_editor.replace_t_with_placeholder_handler`
+*   `tf.contrib.graph_editor.keep_t_if_possible_handler`
+*   `tf.contrib.graph_editor.assign_renamed_collections_handler`
+*   `tf.contrib.graph_editor.transform_op_if_inside_handler`
+*   `tf.contrib.graph_editor.copy_op_handler`
+*   `tf.contrib.graph_editor.Transformer`
+*   `tf.contrib.graph_editor.copy`
+*   `tf.contrib.graph_editor.copy_with_input_replacements`
+*   `tf.contrib.graph_editor.graph_replace`
 
 ## Useful aliases
 
-*   @{tf.contrib.graph_editor.ph}
-*   @{tf.contrib.graph_editor.sgv}
-*   @{tf.contrib.graph_editor.sgv_scope}
+*   `tf.contrib.graph_editor.ph`
+*   `tf.contrib.graph_editor.sgv`
+*   `tf.contrib.graph_editor.sgv_scope`
diff --git a/api_guides/python/contrib.integrate.md b/api_guides/python/contrib.integrate.md
index e95b5a2..a957163 100644
--- a/api_guides/python/contrib.integrate.md
+++ b/api_guides/python/contrib.integrate.md
@@ -6,7 +6,7 @@ Integration and ODE solvers for TensorFlow.
 ## Example: Lorenz attractor
 
 We can use `odeint` to solve the
-[Lorentz system](https://en.wikipedia.org/wiki/Lorenz_system) of ordinary
+[Lorenz system](https://en.wikipedia.org/wiki/Lorenz_system) of ordinary
 differential equations, a prototypical example of chaotic dynamics:
 
 ```python
@@ -38,4 +38,4 @@ plt.plot(x, z)
 
 ## Ops
 
-*   @{tf.contrib.integrate.odeint}
+*   `tf.contrib.integrate.odeint`
diff --git a/api_guides/python/contrib.layers.md b/api_guides/python/contrib.layers.md
index b85db4b..4c176a1 100644
--- a/api_guides/python/contrib.layers.md
+++ b/api_guides/python/contrib.layers.md
@@ -9,29 +9,29 @@ This package provides several ops that take care of creating variables that are
 used internally in a consistent way and provide the building blocks for many
 common machine learning algorithms.
 
-*   @{tf.contrib.layers.avg_pool2d}
-*   @{tf.contrib.layers.batch_norm}
-*   @{tf.contrib.layers.convolution2d}
-*   @{tf.contrib.layers.conv2d_in_plane}
-*   @{tf.contrib.layers.convolution2d_in_plane}
-*   @{tf.nn.conv2d_transpose}
-*   @{tf.contrib.layers.convolution2d_transpose}
-*   @{tf.nn.dropout}
-*   @{tf.contrib.layers.flatten}
-*   @{tf.contrib.layers.fully_connected}
-*   @{tf.contrib.layers.layer_norm}
-*   @{tf.contrib.layers.max_pool2d}
-*   @{tf.contrib.layers.one_hot_encoding}
-*   @{tf.nn.relu}
-*   @{tf.nn.relu6}
-*   @{tf.contrib.layers.repeat}
-*   @{tf.contrib.layers.safe_embedding_lookup_sparse}
-*   @{tf.nn.separable_conv2d}
-*   @{tf.contrib.layers.separable_convolution2d}
-*   @{tf.nn.softmax}
-*   @{tf.stack}
-*   @{tf.contrib.layers.unit_norm}
-*   @{tf.contrib.layers.embed_sequence}
+*   `tf.contrib.layers.avg_pool2d`
+*   `tf.contrib.layers.batch_norm`
+*   `tf.contrib.layers.convolution2d`
+*   `tf.contrib.layers.conv2d_in_plane`
+*   `tf.contrib.layers.convolution2d_in_plane`
+*   `tf.nn.conv2d_transpose`
+*   `tf.contrib.layers.convolution2d_transpose`
+*   `tf.nn.dropout`
+*   `tf.contrib.layers.flatten`
+*   `tf.contrib.layers.fully_connected`
+*   `tf.contrib.layers.layer_norm`
+*   `tf.contrib.layers.max_pool2d`
+*   `tf.contrib.layers.one_hot_encoding`
+*   `tf.nn.relu`
+*   `tf.nn.relu6`
+*   `tf.contrib.layers.repeat`
+*   `tf.contrib.layers.safe_embedding_lookup_sparse`
+*   `tf.nn.separable_conv2d`
+*   `tf.contrib.layers.separable_convolution2d`
+*   `tf.nn.softmax`
+*   `tf.stack`
+*   `tf.contrib.layers.unit_norm`
+*   `tf.contrib.layers.embed_sequence`
 
 Aliases for fully_connected which set a default activation function are
 available: `relu`, `relu6` and `linear`.
@@ -45,65 +45,65 @@ Regularization can help prevent overfitting. These have the signature
 `fn(weights)`. The loss is typically added to
 `tf.GraphKeys.REGULARIZATION_LOSSES`.
 
-*   @{tf.contrib.layers.apply_regularization}
-*   @{tf.contrib.layers.l1_regularizer}
-*   @{tf.contrib.layers.l2_regularizer}
-*   @{tf.contrib.layers.sum_regularizer}
+*   `tf.contrib.layers.apply_regularization`
+*   `tf.contrib.layers.l1_regularizer`
+*   `tf.contrib.layers.l2_regularizer`
+*   `tf.contrib.layers.sum_regularizer`
 
 ## Initializers
 
 Initializers are used to initialize variables with sensible values given their
 size, data type, and purpose.
 
-*   @{tf.contrib.layers.xavier_initializer}
-*   @{tf.contrib.layers.xavier_initializer_conv2d}
-*   @{tf.contrib.layers.variance_scaling_initializer}
+*   `tf.contrib.layers.xavier_initializer`
+*   `tf.contrib.layers.xavier_initializer_conv2d`
+*   `tf.contrib.layers.variance_scaling_initializer`
 
 ## Optimization
 
 Optimize weights given a loss.
 
-*   @{tf.contrib.layers.optimize_loss}
+*   `tf.contrib.layers.optimize_loss`
 
 ## Summaries
 
 Helper functions to summarize specific variables or ops.
 
-*   @{tf.contrib.layers.summarize_activation}
-*   @{tf.contrib.layers.summarize_tensor}
-*   @{tf.contrib.layers.summarize_tensors}
-*   @{tf.contrib.layers.summarize_collection}
+*   `tf.contrib.layers.summarize_activation`
+*   `tf.contrib.layers.summarize_tensor`
+*   `tf.contrib.layers.summarize_tensors`
+*   `tf.contrib.layers.summarize_collection`
 
 The layers module defines convenience functions `summarize_variables`,
 `summarize_weights` and `summarize_biases`, which set the `collection` argument
 of `summarize_collection` to `VARIABLES`, `WEIGHTS` and `BIASES`, respectively.
 
-*   @{tf.contrib.layers.summarize_activations}
+*   `tf.contrib.layers.summarize_activations`
 
 ## Feature columns
 
 Feature columns provide a mechanism to map data to a model.
 
-*   @{tf.contrib.layers.bucketized_column}
-*   @{tf.contrib.layers.check_feature_columns}
-*   @{tf.contrib.layers.create_feature_spec_for_parsing}
-*   @{tf.contrib.layers.crossed_column}
-*   @{tf.contrib.layers.embedding_column}
-*   @{tf.contrib.layers.scattered_embedding_column}
-*   @{tf.contrib.layers.input_from_feature_columns}
-*   @{tf.contrib.layers.joint_weighted_sum_from_feature_columns}
-*   @{tf.contrib.layers.make_place_holder_tensors_for_base_features}
-*   @{tf.contrib.layers.multi_class_target}
-*   @{tf.contrib.layers.one_hot_column}
-*   @{tf.contrib.layers.parse_feature_columns_from_examples}
-*   @{tf.contrib.layers.parse_feature_columns_from_sequence_examples}
-*   @{tf.contrib.layers.real_valued_column}
-*   @{tf.contrib.layers.shared_embedding_columns}
-*   @{tf.contrib.layers.sparse_column_with_hash_bucket}
-*   @{tf.contrib.layers.sparse_column_with_integerized_feature}
-*   @{tf.contrib.layers.sparse_column_with_keys}
-*   @{tf.contrib.layers.sparse_column_with_vocabulary_file}
-*   @{tf.contrib.layers.weighted_sparse_column}
-*   @{tf.contrib.layers.weighted_sum_from_feature_columns}
-*   @{tf.contrib.layers.infer_real_valued_columns}
-*   @{tf.contrib.layers.sequence_input_from_feature_columns}
+*   `tf.contrib.layers.bucketized_column`
+*   `tf.contrib.layers.check_feature_columns`
+*   `tf.contrib.layers.create_feature_spec_for_parsing`
+*   `tf.contrib.layers.crossed_column`
+*   `tf.contrib.layers.embedding_column`
+*   `tf.contrib.layers.scattered_embedding_column`
+*   `tf.contrib.layers.input_from_feature_columns`
+*   `tf.contrib.layers.joint_weighted_sum_from_feature_columns`
+*   `tf.contrib.layers.make_place_holder_tensors_for_base_features`
+*   `tf.contrib.layers.multi_class_target`
+*   `tf.contrib.layers.one_hot_column`
+*   `tf.contrib.layers.parse_feature_columns_from_examples`
+*   `tf.contrib.layers.parse_feature_columns_from_sequence_examples`
+*   `tf.contrib.layers.real_valued_column`
+*   `tf.contrib.layers.shared_embedding_columns`
+*   `tf.contrib.layers.sparse_column_with_hash_bucket`
+*   `tf.contrib.layers.sparse_column_with_integerized_feature`
+*   `tf.contrib.layers.sparse_column_with_keys`
+*   `tf.contrib.layers.sparse_column_with_vocabulary_file`
+*   `tf.contrib.layers.weighted_sparse_column`
+*   `tf.contrib.layers.weighted_sum_from_feature_columns`
+*   `tf.contrib.layers.infer_real_valued_columns`
+*   `tf.contrib.layers.sequence_input_from_feature_columns`
diff --git a/api_guides/python/contrib.learn.md b/api_guides/python/contrib.learn.md
index 8b2fffa..635849e 100644
--- a/api_guides/python/contrib.learn.md
+++ b/api_guides/python/contrib.learn.md
@@ -7,56 +7,57 @@ High level API for learning with TensorFlow.
 
 Train and evaluate TensorFlow models.
 
-*   @{tf.contrib.learn.BaseEstimator}
-*   @{tf.contrib.learn.Estimator}
-*   @{tf.contrib.learn.Trainable}
-*   @{tf.contrib.learn.Evaluable}
-*   @{tf.contrib.learn.KMeansClustering}
-*   @{tf.contrib.learn.ModeKeys}
-*   @{tf.contrib.learn.ModelFnOps}
-*   @{tf.contrib.learn.MetricSpec}
-*   @{tf.contrib.learn.PredictionKey}
-*   @{tf.contrib.learn.DNNClassifier}
-*   @{tf.contrib.learn.DNNRegressor}
-*   @{tf.contrib.learn.DNNLinearCombinedRegressor}
-*   @{tf.contrib.learn.DNNLinearCombinedClassifier}
-*   @{tf.contrib.learn.LinearClassifier}
-*   @{tf.contrib.learn.LinearRegressor}
-*   @{tf.contrib.learn.LogisticRegressor}
+*   `tf.contrib.learn.BaseEstimator`
+*   `tf.contrib.learn.Estimator`
+*   `tf.contrib.learn.Trainable`
+*   `tf.contrib.learn.Evaluable`
+*   `tf.contrib.learn.KMeansClustering`
+*   `tf.contrib.learn.ModeKeys`
+*   `tf.contrib.learn.ModelFnOps`
+*   `tf.contrib.learn.MetricSpec`
+*   `tf.contrib.learn.PredictionKey`
+*   `tf.contrib.learn.DNNClassifier`
+*   `tf.contrib.learn.DNNRegressor`
+*   `tf.contrib.learn.DNNLinearCombinedRegressor`
+*   `tf.contrib.learn.DNNLinearCombinedClassifier`
+*   `tf.contrib.learn.LinearClassifier`
+*   `tf.contrib.learn.LinearRegressor`
+*   `tf.contrib.learn.LogisticRegressor`
 
 ## Distributed training utilities
-*   @{tf.contrib.learn.Experiment}
-*   @{tf.contrib.learn.ExportStrategy}
-*   @{tf.contrib.learn.TaskType}
+
+*   `tf.contrib.learn.Experiment`
+*   `tf.contrib.learn.ExportStrategy`
+*   `tf.contrib.learn.TaskType`
 
 ## Graph actions
 
 Perform various training, evaluation, and inference actions on a graph.
 
-*   @{tf.train.NanLossDuringTrainingError}
-*   @{tf.contrib.learn.RunConfig}
-*   @{tf.contrib.learn.evaluate}
-*   @{tf.contrib.learn.infer}
-*   @{tf.contrib.learn.run_feeds}
-*   @{tf.contrib.learn.run_n}
-*   @{tf.contrib.learn.train}
+*   `tf.train.NanLossDuringTrainingError`
+*   `tf.contrib.learn.RunConfig`
+*   `tf.contrib.learn.evaluate`
+*   `tf.contrib.learn.infer`
+*   `tf.contrib.learn.run_feeds`
+*   `tf.contrib.learn.run_n`
+*   `tf.contrib.learn.train`
 
 ## Input processing
 
 Queue and read batched input data.
 
-*   @{tf.contrib.learn.extract_dask_data}
-*   @{tf.contrib.learn.extract_dask_labels}
-*   @{tf.contrib.learn.extract_pandas_data}
-*   @{tf.contrib.learn.extract_pandas_labels}
-*   @{tf.contrib.learn.extract_pandas_matrix}
-*   @{tf.contrib.learn.infer_real_valued_columns_from_input}
-*   @{tf.contrib.learn.infer_real_valued_columns_from_input_fn}
-*   @{tf.contrib.learn.read_batch_examples}
-*   @{tf.contrib.learn.read_batch_features}
-*   @{tf.contrib.learn.read_batch_record_features}
+*   `tf.contrib.learn.extract_dask_data`
+*   `tf.contrib.learn.extract_dask_labels`
+*   `tf.contrib.learn.extract_pandas_data`
+*   `tf.contrib.learn.extract_pandas_labels`
+*   `tf.contrib.learn.extract_pandas_matrix`
+*   `tf.contrib.learn.infer_real_valued_columns_from_input`
+*   `tf.contrib.learn.infer_real_valued_columns_from_input_fn`
+*   `tf.contrib.learn.read_batch_examples`
+*   `tf.contrib.learn.read_batch_features`
+*   `tf.contrib.learn.read_batch_record_features`
 
 Export utilities
 
-*   @{tf.contrib.learn.build_parsing_serving_input_fn}
-*   @{tf.contrib.learn.ProblemType}
+*   `tf.contrib.learn.build_parsing_serving_input_fn`
+*   `tf.contrib.learn.ProblemType`
diff --git a/api_guides/python/contrib.linalg.md b/api_guides/python/contrib.linalg.md
index c0cb2b1..3055449 100644
--- a/api_guides/python/contrib.linalg.md
+++ b/api_guides/python/contrib.linalg.md
@@ -14,17 +14,17 @@ Subclasses of `LinearOperator` provide a access to common methods on a
 
 ### Base class
 
-*   @{tf.contrib.linalg.LinearOperator}
+*   `tf.contrib.linalg.LinearOperator`
 
 ### Individual operators
 
-*   @{tf.contrib.linalg.LinearOperatorDiag}
-*   @{tf.contrib.linalg.LinearOperatorIdentity}
-*   @{tf.contrib.linalg.LinearOperatorScaledIdentity}
-*   @{tf.contrib.linalg.LinearOperatorFullMatrix}
-*   @{tf.contrib.linalg.LinearOperatorLowerTriangular}
-*   @{tf.contrib.linalg.LinearOperatorLowRankUpdate}
+*   `tf.contrib.linalg.LinearOperatorDiag`
+*   `tf.contrib.linalg.LinearOperatorIdentity`
+*   `tf.contrib.linalg.LinearOperatorScaledIdentity`
+*   `tf.contrib.linalg.LinearOperatorFullMatrix`
+*   `tf.contrib.linalg.LinearOperatorLowerTriangular`
+*   `tf.contrib.linalg.LinearOperatorLowRankUpdate`
 
 ### Transformations and Combinations of operators
 
-*   @{tf.contrib.linalg.LinearOperatorComposition}
+*   `tf.contrib.linalg.LinearOperatorComposition`
diff --git a/api_guides/python/contrib.losses.md b/api_guides/python/contrib.losses.md
index 8b74422..8787454 100644
--- a/api_guides/python/contrib.losses.md
+++ b/api_guides/python/contrib.losses.md
@@ -2,7 +2,7 @@
 
 ## Deprecated
 
-This module is deprecated. Instructions for updating: Use @{tf.losses} instead.
+This module is deprecated. Instructions for updating: Use `tf.losses` instead.
 
 ## Loss operations for use in neural networks.
 
@@ -107,19 +107,19 @@ weighted average over the individual prediction errors:
   loss = tf.contrib.losses.mean_squared_error(predictions, depths, weight)
 ```
 
-* @{tf.contrib.losses.absolute_difference}
-* @{tf.contrib.losses.add_loss}
-* @{tf.contrib.losses.hinge_loss}
-* @{tf.contrib.losses.compute_weighted_loss}
-* @{tf.contrib.losses.cosine_distance}
-* @{tf.contrib.losses.get_losses}
-* @{tf.contrib.losses.get_regularization_losses}
-* @{tf.contrib.losses.get_total_loss}
-* @{tf.contrib.losses.log_loss}
-* @{tf.contrib.losses.mean_pairwise_squared_error}
-* @{tf.contrib.losses.mean_squared_error}
-* @{tf.contrib.losses.sigmoid_cross_entropy}
-* @{tf.contrib.losses.softmax_cross_entropy}
-* @{tf.contrib.losses.sparse_softmax_cross_entropy}
+* `tf.contrib.losses.absolute_difference`
+* `tf.contrib.losses.add_loss`
+* `tf.contrib.losses.hinge_loss`
+* `tf.contrib.losses.compute_weighted_loss`
+* `tf.contrib.losses.cosine_distance`
+* `tf.contrib.losses.get_losses`
+* `tf.contrib.losses.get_regularization_losses`
+* `tf.contrib.losses.get_total_loss`
+* `tf.contrib.losses.log_loss`
+* `tf.contrib.losses.mean_pairwise_squared_error`
+* `tf.contrib.losses.mean_squared_error`
+* `tf.contrib.losses.sigmoid_cross_entropy`
+* `tf.contrib.losses.softmax_cross_entropy`
+* `tf.contrib.losses.sparse_softmax_cross_entropy`
 
 
diff --git a/api_guides/python/contrib.metrics.md b/api_guides/python/contrib.metrics.md
index 1eb9cf4..de6346c 100644
--- a/api_guides/python/contrib.metrics.md
+++ b/api_guides/python/contrib.metrics.md
@@ -86,48 +86,48 @@ labels and predictions tensors and results in a weighted average of the metric.
 
 ## Metric `Ops`
 
-*   @{tf.contrib.metrics.streaming_accuracy}
-*   @{tf.contrib.metrics.streaming_mean}
-*   @{tf.contrib.metrics.streaming_recall}
-*   @{tf.contrib.metrics.streaming_recall_at_thresholds}
-*   @{tf.contrib.metrics.streaming_precision}
-*   @{tf.contrib.metrics.streaming_precision_at_thresholds}
-*   @{tf.contrib.metrics.streaming_auc}
-*   @{tf.contrib.metrics.streaming_recall_at_k}
-*   @{tf.contrib.metrics.streaming_mean_absolute_error}
-*   @{tf.contrib.metrics.streaming_mean_iou}
-*   @{tf.contrib.metrics.streaming_mean_relative_error}
-*   @{tf.contrib.metrics.streaming_mean_squared_error}
-*   @{tf.contrib.metrics.streaming_mean_tensor}
-*   @{tf.contrib.metrics.streaming_root_mean_squared_error}
-*   @{tf.contrib.metrics.streaming_covariance}
-*   @{tf.contrib.metrics.streaming_pearson_correlation}
-*   @{tf.contrib.metrics.streaming_mean_cosine_distance}
-*   @{tf.contrib.metrics.streaming_percentage_less}
-*   @{tf.contrib.metrics.streaming_sensitivity_at_specificity}
-*   @{tf.contrib.metrics.streaming_sparse_average_precision_at_k}
-*   @{tf.contrib.metrics.streaming_sparse_precision_at_k}
-*   @{tf.contrib.metrics.streaming_sparse_precision_at_top_k}
-*   @{tf.contrib.metrics.streaming_sparse_recall_at_k}
-*   @{tf.contrib.metrics.streaming_specificity_at_sensitivity}
-*   @{tf.contrib.metrics.streaming_concat}
-*   @{tf.contrib.metrics.streaming_false_negatives}
-*   @{tf.contrib.metrics.streaming_false_negatives_at_thresholds}
-*   @{tf.contrib.metrics.streaming_false_positives}
-*   @{tf.contrib.metrics.streaming_false_positives_at_thresholds}
-*   @{tf.contrib.metrics.streaming_true_negatives}
-*   @{tf.contrib.metrics.streaming_true_negatives_at_thresholds}
-*   @{tf.contrib.metrics.streaming_true_positives}
-*   @{tf.contrib.metrics.streaming_true_positives_at_thresholds}
-*   @{tf.contrib.metrics.auc_using_histogram}
-*   @{tf.contrib.metrics.accuracy}
-*   @{tf.contrib.metrics.aggregate_metrics}
-*   @{tf.contrib.metrics.aggregate_metric_map}
-*   @{tf.contrib.metrics.confusion_matrix}
+*   `tf.contrib.metrics.streaming_accuracy`
+*   `tf.contrib.metrics.streaming_mean`
+*   `tf.contrib.metrics.streaming_recall`
+*   `tf.contrib.metrics.streaming_recall_at_thresholds`
+*   `tf.contrib.metrics.streaming_precision`
+*   `tf.contrib.metrics.streaming_precision_at_thresholds`
+*   `tf.contrib.metrics.streaming_auc`
+*   `tf.contrib.metrics.streaming_recall_at_k`
+*   `tf.contrib.metrics.streaming_mean_absolute_error`
+*   `tf.contrib.metrics.streaming_mean_iou`
+*   `tf.contrib.metrics.streaming_mean_relative_error`
+*   `tf.contrib.metrics.streaming_mean_squared_error`
+*   `tf.contrib.metrics.streaming_mean_tensor`
+*   `tf.contrib.metrics.streaming_root_mean_squared_error`
+*   `tf.contrib.metrics.streaming_covariance`
+*   `tf.contrib.metrics.streaming_pearson_correlation`
+*   `tf.contrib.metrics.streaming_mean_cosine_distance`
+*   `tf.contrib.metrics.streaming_percentage_less`
+*   `tf.contrib.metrics.streaming_sensitivity_at_specificity`
+*   `tf.contrib.metrics.streaming_sparse_average_precision_at_k`
+*   `tf.contrib.metrics.streaming_sparse_precision_at_k`
+*   `tf.contrib.metrics.streaming_sparse_precision_at_top_k`
+*   `tf.contrib.metrics.streaming_sparse_recall_at_k`
+*   `tf.contrib.metrics.streaming_specificity_at_sensitivity`
+*   `tf.contrib.metrics.streaming_concat`
+*   `tf.contrib.metrics.streaming_false_negatives`
+*   `tf.contrib.metrics.streaming_false_negatives_at_thresholds`
+*   `tf.contrib.metrics.streaming_false_positives`
+*   `tf.contrib.metrics.streaming_false_positives_at_thresholds`
+*   `tf.contrib.metrics.streaming_true_negatives`
+*   `tf.contrib.metrics.streaming_true_negatives_at_thresholds`
+*   `tf.contrib.metrics.streaming_true_positives`
+*   `tf.contrib.metrics.streaming_true_positives_at_thresholds`
+*   `tf.contrib.metrics.auc_using_histogram`
+*   `tf.contrib.metrics.accuracy`
+*   `tf.contrib.metrics.aggregate_metrics`
+*   `tf.contrib.metrics.aggregate_metric_map`
+*   `tf.contrib.metrics.confusion_matrix`
 
 ## Set `Ops`
 
-*   @{tf.contrib.metrics.set_difference}
-*   @{tf.contrib.metrics.set_intersection}
-*   @{tf.contrib.metrics.set_size}
-*   @{tf.contrib.metrics.set_union}
+*   `tf.contrib.metrics.set_difference`
+*   `tf.contrib.metrics.set_intersection`
+*   `tf.contrib.metrics.set_size`
+*   `tf.contrib.metrics.set_union`
diff --git a/api_guides/python/contrib.rnn.md b/api_guides/python/contrib.rnn.md
index d089b06..d265ab6 100644
--- a/api_guides/python/contrib.rnn.md
+++ b/api_guides/python/contrib.rnn.md
@@ -5,49 +5,49 @@ Module for constructing RNN Cells and additional RNN operations.
 
 ## Base interface for all RNN Cells
 
-*   @{tf.contrib.rnn.RNNCell}
+*   `tf.contrib.rnn.RNNCell`
 
 ## Core RNN Cells for use with TensorFlow's core RNN methods
 
-*   @{tf.contrib.rnn.BasicRNNCell}
-*   @{tf.contrib.rnn.BasicLSTMCell}
-*   @{tf.contrib.rnn.GRUCell}
-*   @{tf.contrib.rnn.LSTMCell}
-*   @{tf.contrib.rnn.LayerNormBasicLSTMCell}
+*   `tf.contrib.rnn.BasicRNNCell`
+*   `tf.contrib.rnn.BasicLSTMCell`
+*   `tf.contrib.rnn.GRUCell`
+*   `tf.contrib.rnn.LSTMCell`
+*   `tf.contrib.rnn.LayerNormBasicLSTMCell`
 
 ## Classes storing split `RNNCell` state
 
-*   @{tf.contrib.rnn.LSTMStateTuple}
+*   `tf.contrib.rnn.LSTMStateTuple`
 
 ## Core RNN Cell wrappers (RNNCells that wrap other RNNCells)
 
-*   @{tf.contrib.rnn.MultiRNNCell}
-*   @{tf.contrib.rnn.LSTMBlockWrapper}
-*   @{tf.contrib.rnn.DropoutWrapper}
-*   @{tf.contrib.rnn.EmbeddingWrapper}
-*   @{tf.contrib.rnn.InputProjectionWrapper}
-*   @{tf.contrib.rnn.OutputProjectionWrapper}
-*   @{tf.contrib.rnn.DeviceWrapper}
-*   @{tf.contrib.rnn.ResidualWrapper}
+*   `tf.contrib.rnn.MultiRNNCell`
+*   `tf.contrib.rnn.LSTMBlockWrapper`
+*   `tf.contrib.rnn.DropoutWrapper`
+*   `tf.contrib.rnn.EmbeddingWrapper`
+*   `tf.contrib.rnn.InputProjectionWrapper`
+*   `tf.contrib.rnn.OutputProjectionWrapper`
+*   `tf.contrib.rnn.DeviceWrapper`
+*   `tf.contrib.rnn.ResidualWrapper`
 
 ### Block RNNCells
-*   @{tf.contrib.rnn.LSTMBlockCell}
-*   @{tf.contrib.rnn.GRUBlockCell}
+*   `tf.contrib.rnn.LSTMBlockCell`
+*   `tf.contrib.rnn.GRUBlockCell`
 
 ### Fused RNNCells
-*   @{tf.contrib.rnn.FusedRNNCell}
-*   @{tf.contrib.rnn.FusedRNNCellAdaptor}
-*   @{tf.contrib.rnn.TimeReversedFusedRNN}
-*   @{tf.contrib.rnn.LSTMBlockFusedCell}
+*   `tf.contrib.rnn.FusedRNNCell`
+*   `tf.contrib.rnn.FusedRNNCellAdaptor`
+*   `tf.contrib.rnn.TimeReversedFusedRNN`
+*   `tf.contrib.rnn.LSTMBlockFusedCell`
 
 ### LSTM-like cells
-*   @{tf.contrib.rnn.CoupledInputForgetGateLSTMCell}
-*   @{tf.contrib.rnn.TimeFreqLSTMCell}
-*   @{tf.contrib.rnn.GridLSTMCell}
+*   `tf.contrib.rnn.CoupledInputForgetGateLSTMCell`
+*   `tf.contrib.rnn.TimeFreqLSTMCell`
+*   `tf.contrib.rnn.GridLSTMCell`
 
 ### RNNCell wrappers
-*   @{tf.contrib.rnn.AttentionCellWrapper}
-*   @{tf.contrib.rnn.CompiledWrapper}
+*   `tf.contrib.rnn.AttentionCellWrapper`
+*   `tf.contrib.rnn.CompiledWrapper`
 
 
 ## Recurrent Neural Networks
@@ -55,7 +55,7 @@ Module for constructing RNN Cells and additional RNN operations.
 TensorFlow provides a number of methods for constructing Recurrent Neural
 Networks.
 
-*   @{tf.contrib.rnn.static_rnn}
-*   @{tf.contrib.rnn.static_state_saving_rnn}
-*   @{tf.contrib.rnn.static_bidirectional_rnn}
-*   @{tf.contrib.rnn.stack_bidirectional_dynamic_rnn}
+*   `tf.contrib.rnn.static_rnn`
+*   `tf.contrib.rnn.static_state_saving_rnn`
+*   `tf.contrib.rnn.static_bidirectional_rnn`
+*   `tf.contrib.rnn.stack_bidirectional_dynamic_rnn`
diff --git a/api_guides/python/contrib.seq2seq.md b/api_guides/python/contrib.seq2seq.md
index 496d43d..54f2faf 100644
--- a/api_guides/python/contrib.seq2seq.md
+++ b/api_guides/python/contrib.seq2seq.md
@@ -2,18 +2,18 @@
 [TOC]
 
 Module for constructing seq2seq models and dynamic decoding.  Builds on top of
-libraries in @{tf.contrib.rnn}.
+libraries in `tf.contrib.rnn`.
 
 This library is composed of two primary components:
 
-*   New attention wrappers for @{tf.contrib.rnn.RNNCell} objects.
+*   New attention wrappers for `tf.contrib.rnn.RNNCell` objects.
 *   A new object-oriented dynamic decoding framework.
 
 ## Attention
 
 Attention wrappers are `RNNCell` objects that wrap other `RNNCell` objects and
 implement attention.  The form of attention is determined by a subclass of
-@{tf.contrib.seq2seq.AttentionMechanism}.  These subclasses describe the form
+`tf.contrib.seq2seq.AttentionMechanism`.  These subclasses describe the form
 of attention (e.g. additive vs. multiplicative) to use when creating the
 wrapper.  An instance of an `AttentionMechanism` is constructed with a
 `memory` tensor, from which lookup keys and values tensors are created.
@@ -21,9 +21,10 @@ wrapper.  An instance of an `AttentionMechanism` is constructed with a
 ### Attention Mechanisms
 
 The two basic attention mechanisms are:
-*   @{tf.contrib.seq2seq.BahdanauAttention} (additive attention,
+
+*   `tf.contrib.seq2seq.BahdanauAttention` (additive attention,
     [ref.](https://arxiv.org/abs/1409.0473))
-*   @{tf.contrib.seq2seq.LuongAttention} (multiplicative attention,
+*   `tf.contrib.seq2seq.LuongAttention` (multiplicative attention,
     [ref.](https://arxiv.org/abs/1508.04025))
 
 The `memory` tensor passed the attention mechanism's constructor is expected to
@@ -40,7 +41,7 @@ depth.
 
 ### Attention Wrappers
 
-The basic attention wrapper is @{tf.contrib.seq2seq.AttentionWrapper}.
+The basic attention wrapper is `tf.contrib.seq2seq.AttentionWrapper`.
 This wrapper accepts an `RNNCell` instance, an instance of `AttentionMechanism`,
 and an attention depth parameter (`attention_size`); as well as several
 optional arguments that allow one to customize intermediate calculations.
@@ -118,17 +119,20 @@ outputs, _ = tf.contrib.seq2seq.dynamic_decode(
 ```
 
 ### Decoder base class and functions
-*   @{tf.contrib.seq2seq.Decoder}
-*   @{tf.contrib.seq2seq.dynamic_decode}
+
+*   `tf.contrib.seq2seq.Decoder`
+*   `tf.contrib.seq2seq.dynamic_decode`
 
 ### Basic Decoder
-*   @{tf.contrib.seq2seq.BasicDecoderOutput}
-*   @{tf.contrib.seq2seq.BasicDecoder}
+
+*   `tf.contrib.seq2seq.BasicDecoderOutput`
+*   `tf.contrib.seq2seq.BasicDecoder`
 
 ### Decoder Helpers
-*   @{tf.contrib.seq2seq.Helper}
-*   @{tf.contrib.seq2seq.CustomHelper}
-*   @{tf.contrib.seq2seq.GreedyEmbeddingHelper}
-*   @{tf.contrib.seq2seq.ScheduledEmbeddingTrainingHelper}
-*   @{tf.contrib.seq2seq.ScheduledOutputTrainingHelper}
-*   @{tf.contrib.seq2seq.TrainingHelper}
+
+*   `tf.contrib.seq2seq.Helper`
+*   `tf.contrib.seq2seq.CustomHelper`
+*   `tf.contrib.seq2seq.GreedyEmbeddingHelper`
+*   `tf.contrib.seq2seq.ScheduledEmbeddingTrainingHelper`
+*   `tf.contrib.seq2seq.ScheduledOutputTrainingHelper`
+*   `tf.contrib.seq2seq.TrainingHelper`
diff --git a/api_guides/python/contrib.signal.md b/api_guides/python/contrib.signal.md
index 0f7690f..66df561 100644
--- a/api_guides/python/contrib.signal.md
+++ b/api_guides/python/contrib.signal.md
@@ -1,7 +1,7 @@
 # Signal Processing (contrib)
 [TOC]
 
-@{tf.contrib.signal} is a module for signal processing primitives. All
+`tf.contrib.signal` is a module for signal processing primitives. All
 operations have GPU support and are differentiable. This module is especially
 helpful for building TensorFlow models that process or generate audio, though
 the techniques are useful in many domains.
@@ -10,7 +10,7 @@ the techniques are useful in many domains.
 
 When dealing with variable length signals (e.g. audio) it is common to "frame"
 them into multiple fixed length windows. These windows can overlap if the 'step'
-of the frame is less than the frame length. @{tf.contrib.signal.frame} does
+of the frame is less than the frame length. `tf.contrib.signal.frame` does
 exactly this. For example:
 
 ```python
@@ -24,7 +24,7 @@ signals = tf.placeholder(tf.float32, [None, None])
 frames = tf.contrib.signal.frame(signals, frame_length=128, frame_step=32)
 ```
 
-The `axis` parameter to @{tf.contrib.signal.frame} allows you to frame tensors
+The `axis` parameter to `tf.contrib.signal.frame` allows you to frame tensors
 with inner structure (e.g. a spectrogram):
 
 ```python
@@ -42,7 +42,7 @@ spectrogram_patches = tf.contrib.signal.frame(
 
 ## Reconstructing framed sequences and applying a tapering window
 
-@{tf.contrib.signal.overlap_and_add} can be used to reconstruct a signal from a
+`tf.contrib.signal.overlap_and_add` can be used to reconstruct a signal from a
 framed representation. For example, the following code reconstructs the signal
 produced in the preceding example:
 
@@ -58,7 +58,7 @@ the resulting reconstruction will have a greater magnitude than the original
 window function satisfies the Constant Overlap-Add (COLA) property for the given
 frame step, then it will recover the original `signals`.
 
-@{tf.contrib.signal.hamming_window} and @{tf.contrib.signal.hann_window} both
+`tf.contrib.signal.hamming_window` and `tf.contrib.signal.hann_window` both
 satisfy the COLA property for a 75% overlap.
 
 ```python
@@ -74,7 +74,7 @@ reconstructed_signals = tf.contrib.signal.overlap_and_add(
 A spectrogram is a time-frequency decomposition of a signal that indicates its
 frequency content over time. The most common approach to computing spectrograms
 is to take the magnitude of the [Short-time Fourier Transform][stft] (STFT),
-which @{tf.contrib.signal.stft} can compute as follows:
+which `tf.contrib.signal.stft` can compute as follows:
 
 ```python
 # A batch of float32 time-domain signals in the range [-1, 1] with shape
@@ -121,7 +121,7 @@ When working with spectral representations of audio, the [mel scale][mel] is a
 common reweighting of the frequency dimension, which results in a
 lower-dimensional and more perceptually-relevant representation of the audio.
 
-@{tf.contrib.signal.linear_to_mel_weight_matrix} produces a matrix you can use
+`tf.contrib.signal.linear_to_mel_weight_matrix` produces a matrix you can use
 to convert a spectrogram to the mel scale.
 
 ```python
@@ -156,7 +156,7 @@ log_mel_spectrograms = tf.log(mel_spectrograms + log_offset)
 
 ## Computing Mel-Frequency Cepstral Coefficients (MFCCs)
 
-Call @{tf.contrib.signal.mfccs_from_log_mel_spectrograms} to compute
+Call `tf.contrib.signal.mfccs_from_log_mel_spectrograms` to compute
 [MFCCs][mfcc] from log-magnitude, mel-scale spectrograms (as computed in the
 preceding example):
 
diff --git a/api_guides/python/contrib.staging.md b/api_guides/python/contrib.staging.md
index b0ac548..de143a7 100644
--- a/api_guides/python/contrib.staging.md
+++ b/api_guides/python/contrib.staging.md
@@ -3,4 +3,4 @@
 
 This library contains utilities for adding pipelining to a model.
 
-*   @{tf.contrib.staging.StagingArea}
+*   `tf.contrib.staging.StagingArea`
diff --git a/api_guides/python/contrib.training.md b/api_guides/python/contrib.training.md
index 87395d9..068efdc 100644
--- a/api_guides/python/contrib.training.md
+++ b/api_guides/python/contrib.training.md
@@ -5,46 +5,46 @@ Training and input utilities.
 
 ## Splitting sequence inputs into minibatches with state saving
 
-Use @{tf.contrib.training.SequenceQueueingStateSaver} or
-its wrapper @{tf.contrib.training.batch_sequences_with_states} if
+Use `tf.contrib.training.SequenceQueueingStateSaver` or
+its wrapper `tf.contrib.training.batch_sequences_with_states` if
 you have input data with a dynamic primary time / frame count axis which
 you'd like to convert into fixed size segments during minibatching, and would
 like to store state in the forward direction across segments of an example.
 
-*   @{tf.contrib.training.batch_sequences_with_states}
-*   @{tf.contrib.training.NextQueuedSequenceBatch}
-*   @{tf.contrib.training.SequenceQueueingStateSaver}
+*   `tf.contrib.training.batch_sequences_with_states`
+*   `tf.contrib.training.NextQueuedSequenceBatch`
+*   `tf.contrib.training.SequenceQueueingStateSaver`
 
 
 ## Online data resampling
 
 To resample data with replacement on a per-example basis, use
-@{tf.contrib.training.rejection_sample} or
-@{tf.contrib.training.resample_at_rate}. For `rejection_sample`, provide
+`tf.contrib.training.rejection_sample` or
+`tf.contrib.training.resample_at_rate`. For `rejection_sample`, provide
 a boolean Tensor describing whether to accept or reject. Resulting batch sizes
 are always the same. For `resample_at_rate`, provide the desired rate for each
 example. Resulting batch sizes may vary. If you wish to specify relative
-rates, rather than absolute ones, use @{tf.contrib.training.weighted_resample}
+rates, rather than absolute ones, use `tf.contrib.training.weighted_resample`
 (which also returns the actual resampling rate used for each output example).
 
-Use @{tf.contrib.training.stratified_sample} to resample without replacement
+Use `tf.contrib.training.stratified_sample` to resample without replacement
 from the data to achieve a desired mix of class proportions that the Tensorflow
 graph sees. For instance, if you have a binary classification dataset that is
 99.9% class 1, a common approach is to resample from the data so that the data
 is more balanced.
 
-*   @{tf.contrib.training.rejection_sample}
-*   @{tf.contrib.training.resample_at_rate}
-*   @{tf.contrib.training.stratified_sample}
-*   @{tf.contrib.training.weighted_resample}
+*   `tf.contrib.training.rejection_sample`
+*   `tf.contrib.training.resample_at_rate`
+*   `tf.contrib.training.stratified_sample`
+*   `tf.contrib.training.weighted_resample`
 
 ## Bucketing
 
-Use @{tf.contrib.training.bucket} or
-@{tf.contrib.training.bucket_by_sequence_length} to stratify
+Use `tf.contrib.training.bucket` or
+`tf.contrib.training.bucket_by_sequence_length` to stratify
 minibatches into groups ("buckets").  Use `bucket_by_sequence_length`
 with the argument `dynamic_pad=True` to receive minibatches of similarly
 sized sequences for efficient training via `dynamic_rnn`.
 
-*   @{tf.contrib.training.bucket}
-*   @{tf.contrib.training.bucket_by_sequence_length}
+*   `tf.contrib.training.bucket`
+*   `tf.contrib.training.bucket_by_sequence_length`
diff --git a/api_guides/python/contrib.util.md b/api_guides/python/contrib.util.md
index 6bc120d..e5fd97e 100644
--- a/api_guides/python/contrib.util.md
+++ b/api_guides/python/contrib.util.md
@@ -5,8 +5,8 @@ Utilities for dealing with Tensors.
 
 ## Miscellaneous Utility Functions
 
-*   @{tf.contrib.util.constant_value}
-*   @{tf.contrib.util.make_tensor_proto}
-*   @{tf.contrib.util.make_ndarray}
-*   @{tf.contrib.util.ops_used_by_graph_def}
-*   @{tf.contrib.util.stripped_op_list_for_graph}
+*   `tf.contrib.util.constant_value`
+*   `tf.contrib.util.make_tensor_proto`
+*   `tf.contrib.util.make_ndarray`
+*   `tf.contrib.util.ops_used_by_graph_def`
+*   `tf.contrib.util.stripped_op_list_for_graph`
diff --git a/api_guides/python/control_flow_ops.md b/api_guides/python/control_flow_ops.md
index 68ea96d..42c86d9 100644
--- a/api_guides/python/control_flow_ops.md
+++ b/api_guides/python/control_flow_ops.md
@@ -1,7 +1,7 @@
 # Control Flow
 
 Note: Functions taking `Tensor` arguments can also take anything accepted by
-@{tf.convert_to_tensor}.
+`tf.convert_to_tensor`.
 
 [TOC]
 
@@ -10,48 +10,48 @@ Note: Functions taking `Tensor` arguments can also take anything accepted by
 TensorFlow provides several operations and classes that you can use to control
 the execution of operations and add conditional dependencies to your graph.
 
-*   @{tf.identity}
-*   @{tf.tuple}
-*   @{tf.group}
-*   @{tf.no_op}
-*   @{tf.count_up_to}
-*   @{tf.cond}
-*   @{tf.case}
-*   @{tf.while_loop}
+*   `tf.identity`
+*   `tf.tuple`
+*   `tf.group`
+*   `tf.no_op`
+*   `tf.count_up_to`
+*   `tf.cond`
+*   `tf.case`
+*   `tf.while_loop`
 
 ## Logical Operators
 
 TensorFlow provides several operations that you can use to add logical operators
 to your graph.
 
-*   @{tf.logical_and}
-*   @{tf.logical_not}
-*   @{tf.logical_or}
-*   @{tf.logical_xor}
+*   `tf.logical_and`
+*   `tf.logical_not`
+*   `tf.logical_or`
+*   `tf.logical_xor`
 
 ## Comparison Operators
 
 TensorFlow provides several operations that you can use to add comparison
 operators to your graph.
 
-*   @{tf.equal}
-*   @{tf.not_equal}
-*   @{tf.less}
-*   @{tf.less_equal}
-*   @{tf.greater}
-*   @{tf.greater_equal}
-*   @{tf.where}
+*   `tf.equal`
+*   `tf.not_equal`
+*   `tf.less`
+*   `tf.less_equal`
+*   `tf.greater`
+*   `tf.greater_equal`
+*   `tf.where`
 
 ## Debugging Operations
 
 TensorFlow provides several operations that you can use to validate values and
 debug your graph.
 
-*   @{tf.is_finite}
-*   @{tf.is_inf}
-*   @{tf.is_nan}
-*   @{tf.verify_tensor_all_finite}
-*   @{tf.check_numerics}
-*   @{tf.add_check_numerics_ops}
-*   @{tf.Assert}
-*   @{tf.Print}
+*   `tf.is_finite`
+*   `tf.is_inf`
+*   `tf.is_nan`
+*   `tf.verify_tensor_all_finite`
+*   `tf.check_numerics`
+*   `tf.add_check_numerics_ops`
+*   `tf.Assert`
+*   `tf.Print`
diff --git a/api_guides/python/framework.md b/api_guides/python/framework.md
index 42c3e57..40a6c07 100644
--- a/api_guides/python/framework.md
+++ b/api_guides/python/framework.md
@@ -5,47 +5,47 @@ Classes and functions for building TensorFlow graphs.
 
 ## Core graph data structures
 
-*   @{tf.Graph}
-*   @{tf.Operation}
-*   @{tf.Tensor}
+*   `tf.Graph`
+*   `tf.Operation`
+*   `tf.Tensor`
 
 ## Tensor types
 
-*   @{tf.DType}
-*   @{tf.as_dtype}
+*   `tf.DType`
+*   `tf.as_dtype`
 
 ## Utility functions
 
-*   @{tf.device}
-*   @{tf.container}
-*   @{tf.name_scope}
-*   @{tf.control_dependencies}
-*   @{tf.convert_to_tensor}
-*   @{tf.convert_to_tensor_or_indexed_slices}
-*   @{tf.convert_to_tensor_or_sparse_tensor}
-*   @{tf.get_default_graph}
-*   @{tf.reset_default_graph}
-*   @{tf.import_graph_def}
-*   @{tf.load_file_system_library}
-*   @{tf.load_op_library}
+*   `tf.device`
+*   `tf.container`
+*   `tf.name_scope`
+*   `tf.control_dependencies`
+*   `tf.convert_to_tensor`
+*   `tf.convert_to_tensor_or_indexed_slices`
+*   `tf.convert_to_tensor_or_sparse_tensor`
+*   `tf.get_default_graph`
+*   `tf.reset_default_graph`
+*   `tf.import_graph_def`
+*   `tf.load_file_system_library`
+*   `tf.load_op_library`
 
 ## Graph collections
 
-*   @{tf.add_to_collection}
-*   @{tf.get_collection}
-*   @{tf.get_collection_ref}
-*   @{tf.GraphKeys}
+*   `tf.add_to_collection`
+*   `tf.get_collection`
+*   `tf.get_collection_ref`
+*   `tf.GraphKeys`
 
 ## Defining new operations
 
-*   @{tf.RegisterGradient}
-*   @{tf.NotDifferentiable}
-*   @{tf.NoGradient}
-*   @{tf.TensorShape}
-*   @{tf.Dimension}
-*   @{tf.op_scope}
-*   @{tf.get_seed}
+*   `tf.RegisterGradient`
+*   `tf.NotDifferentiable`
+*   `tf.NoGradient`
+*   `tf.TensorShape`
+*   `tf.Dimension`
+*   `tf.op_scope`
+*   `tf.get_seed`
 
 ## For libraries building on TensorFlow
 
-*   @{tf.register_tensor_conversion_function}
+*   `tf.register_tensor_conversion_function`
diff --git a/api_guides/python/functional_ops.md b/api_guides/python/functional_ops.md
index 9fd4606..0a9fe02 100644
--- a/api_guides/python/functional_ops.md
+++ b/api_guides/python/functional_ops.md
@@ -1,7 +1,7 @@
 # Higher Order Functions
 
 Note: Functions taking `Tensor` arguments can also take anything accepted by
-@{tf.convert_to_tensor}.
+`tf.convert_to_tensor`.
 
 [TOC]
 
@@ -12,7 +12,7 @@ Functional operations.
 TensorFlow provides several higher order operators to simplify the common
 map-reduce programming patterns.
 
-*   @{tf.map_fn}
-*   @{tf.foldl}
-*   @{tf.foldr}
-*   @{tf.scan}
+*   `tf.map_fn`
+*   `tf.foldl`
+*   `tf.foldr`
+*   `tf.scan`
diff --git a/api_guides/python/image.md b/api_guides/python/image.md
index 051e454..c51b92d 100644
--- a/api_guides/python/image.md
+++ b/api_guides/python/image.md
@@ -1,7 +1,7 @@
 # Images
 
 Note: Functions taking `Tensor` arguments can also take anything accepted by
-@{tf.convert_to_tensor}.
+`tf.convert_to_tensor`.
 
 [TOC]
 
@@ -19,27 +19,27 @@ Note: The PNG encode and decode Ops support RGBA, but the conversions Ops
 presently only support RGB, HSV, and GrayScale. Presently, the alpha channel has
 to be stripped from the image and re-attached using slicing ops.
 
-*   @{tf.image.decode_bmp}
-*   @{tf.image.decode_gif}
-*   @{tf.image.decode_jpeg}
-*   @{tf.image.encode_jpeg}
-*   @{tf.image.decode_png}
-*   @{tf.image.encode_png}
-*   @{tf.image.decode_image}
+*   `tf.image.decode_bmp`
+*   `tf.image.decode_gif`
+*   `tf.image.decode_jpeg`
+*   `tf.image.encode_jpeg`
+*   `tf.image.decode_png`
+*   `tf.image.encode_png`
+*   `tf.image.decode_image`
 
 ## Resizing
 
 The resizing Ops accept input images as tensors of several types.  They always
 output resized images as float32 tensors.
 
-The convenience function @{tf.image.resize_images} supports both 4-D
+The convenience function `tf.image.resize_images` supports both 4-D
 and 3-D tensors as input and output.  4-D tensors are for batches of images,
 3-D tensors for individual images.
 
 Other resizing Ops only support 4-D batches of images as input:
-@{tf.image.resize_area}, @{tf.image.resize_bicubic},
-@{tf.image.resize_bilinear},
-@{tf.image.resize_nearest_neighbor}.
+`tf.image.resize_area`, `tf.image.resize_bicubic`,
+`tf.image.resize_bilinear`,
+`tf.image.resize_nearest_neighbor`.
 
 Example:
 
@@ -49,29 +49,29 @@ image = tf.image.decode_jpeg(...)
 resized_image = tf.image.resize_images(image, [299, 299])
 ```
 
-*   @{tf.image.resize_images}
-*   @{tf.image.resize_area}
-*   @{tf.image.resize_bicubic}
-*   @{tf.image.resize_bilinear}
-*   @{tf.image.resize_nearest_neighbor}
+*   `tf.image.resize_images`
+*   `tf.image.resize_area`
+*   `tf.image.resize_bicubic`
+*   `tf.image.resize_bilinear`
+*   `tf.image.resize_nearest_neighbor`
 
 ## Cropping
 
-*   @{tf.image.resize_image_with_crop_or_pad}
-*   @{tf.image.central_crop}
-*   @{tf.image.pad_to_bounding_box}
-*   @{tf.image.crop_to_bounding_box}
-*   @{tf.image.extract_glimpse}
-*   @{tf.image.crop_and_resize}
+*   `tf.image.resize_image_with_crop_or_pad`
+*   `tf.image.central_crop`
+*   `tf.image.pad_to_bounding_box`
+*   `tf.image.crop_to_bounding_box`
+*   `tf.image.extract_glimpse`
+*   `tf.image.crop_and_resize`
 
 ## Flipping, Rotating and Transposing
 
-*   @{tf.image.flip_up_down}
-*   @{tf.image.random_flip_up_down}
-*   @{tf.image.flip_left_right}
-*   @{tf.image.random_flip_left_right}
-*   @{tf.image.transpose_image}
-*   @{tf.image.rot90}
+*   `tf.image.flip_up_down`
+*   `tf.image.random_flip_up_down`
+*   `tf.image.flip_left_right`
+*   `tf.image.random_flip_left_right`
+*   `tf.image.transpose_image`
+*   `tf.image.rot90`
 
 ## Converting Between Colorspaces
 
@@ -94,7 +94,7 @@ per pixel (values are assumed to lie in `[0,255]`).
 
 TensorFlow can convert between images in RGB or HSV. The conversion functions
 work only on float images, so you need to convert images in other formats using
-@{tf.image.convert_image_dtype}.
+`tf.image.convert_image_dtype`.
 
 Example:
 
@@ -105,11 +105,11 @@ rgb_image_float = tf.image.convert_image_dtype(rgb_image, tf.float32)
 hsv_image = tf.image.rgb_to_hsv(rgb_image)
 ```
 
-*   @{tf.image.rgb_to_grayscale}
-*   @{tf.image.grayscale_to_rgb}
-*   @{tf.image.hsv_to_rgb}
-*   @{tf.image.rgb_to_hsv}
-*   @{tf.image.convert_image_dtype}
+*   `tf.image.rgb_to_grayscale`
+*   `tf.image.grayscale_to_rgb`
+*   `tf.image.hsv_to_rgb`
+*   `tf.image.rgb_to_hsv`
+*   `tf.image.convert_image_dtype`
 
 ## Image Adjustments
 
@@ -122,23 +122,23 @@ If several adjustments are chained it is advisable to minimize the number of
 redundant conversions by first converting the images to the most natural data
 type and representation (RGB or HSV).
 
-*   @{tf.image.adjust_brightness}
-*   @{tf.image.random_brightness}
-*   @{tf.image.adjust_contrast}
-*   @{tf.image.random_contrast}
-*   @{tf.image.adjust_hue}
-*   @{tf.image.random_hue}
-*   @{tf.image.adjust_gamma}
-*   @{tf.image.adjust_saturation}
-*   @{tf.image.random_saturation}
-*   @{tf.image.per_image_standardization}
+*   `tf.image.adjust_brightness`
+*   `tf.image.random_brightness`
+*   `tf.image.adjust_contrast`
+*   `tf.image.random_contrast`
+*   `tf.image.adjust_hue`
+*   `tf.image.random_hue`
+*   `tf.image.adjust_gamma`
+*   `tf.image.adjust_saturation`
+*   `tf.image.random_saturation`
+*   `tf.image.per_image_standardization`
 
 ## Working with Bounding Boxes
 
-*   @{tf.image.draw_bounding_boxes}
-*   @{tf.image.non_max_suppression}
-*   @{tf.image.sample_distorted_bounding_box}
+*   `tf.image.draw_bounding_boxes`
+*   `tf.image.non_max_suppression`
+*   `tf.image.sample_distorted_bounding_box`
 
 ## Denoising
 
-*   @{tf.image.total_variation}
+*   `tf.image.total_variation`
diff --git a/api_guides/python/input_dataset.md b/api_guides/python/input_dataset.md
index a6e2fc4..911a76c 100644
--- a/api_guides/python/input_dataset.md
+++ b/api_guides/python/input_dataset.md
@@ -1,28 +1,27 @@
 # Dataset Input Pipeline
 [TOC]
 
-@{tf.data.Dataset} allows you to build complex input pipelines. See the
-@{$datasets$programmer's guide} for an in-depth explanation of how to use this
-API.
+`tf.data.Dataset` allows you to build complex input pipelines. See the
+[Importing Data](../../guide/datasets.md) for an in-depth explanation of how to use this API.
 
 ## Reader classes
 
 Classes that create a dataset from input files.
 
-*   @{tf.data.FixedLengthRecordDataset}
-*   @{tf.data.TextLineDataset}
-*   @{tf.data.TFRecordDataset}
+*   `tf.data.FixedLengthRecordDataset`
+*   `tf.data.TextLineDataset`
+*   `tf.data.TFRecordDataset`
 
 ## Creating new datasets
 
 Static methods in `Dataset` that create new datasets.
 
-*   @{tf.data.Dataset.from_generator}
-*   @{tf.data.Dataset.from_tensor_slices}
-*   @{tf.data.Dataset.from_tensors}
-*   @{tf.data.Dataset.list_files}
-*   @{tf.data.Dataset.range}
-*   @{tf.data.Dataset.zip}
+*   `tf.data.Dataset.from_generator`
+*   `tf.data.Dataset.from_tensor_slices`
+*   `tf.data.Dataset.from_tensors`
+*   `tf.data.Dataset.list_files`
+*   `tf.data.Dataset.range`
+*   `tf.data.Dataset.zip`
 
 ## Transformations on existing datasets
 
@@ -33,54 +32,54 @@ can be chained together, as shown in the example below:
 train_data = train_data.batch(100).shuffle().repeat()
 ```
 
-*   @{tf.data.Dataset.apply}
-*   @{tf.data.Dataset.batch}
-*   @{tf.data.Dataset.cache}
-*   @{tf.data.Dataset.concatenate}
-*   @{tf.data.Dataset.filter}
-*   @{tf.data.Dataset.flat_map}
-*   @{tf.data.Dataset.interleave}
-*   @{tf.data.Dataset.map}
-*   @{tf.data.Dataset.padded_batch}
-*   @{tf.data.Dataset.prefetch}
-*   @{tf.data.Dataset.repeat}
-*   @{tf.data.Dataset.shard}
-*   @{tf.data.Dataset.shuffle}
-*   @{tf.data.Dataset.skip}
-*   @{tf.data.Dataset.take}
+*   `tf.data.Dataset.apply`
+*   `tf.data.Dataset.batch`
+*   `tf.data.Dataset.cache`
+*   `tf.data.Dataset.concatenate`
+*   `tf.data.Dataset.filter`
+*   `tf.data.Dataset.flat_map`
+*   `tf.data.Dataset.interleave`
+*   `tf.data.Dataset.map`
+*   `tf.data.Dataset.padded_batch`
+*   `tf.data.Dataset.prefetch`
+*   `tf.data.Dataset.repeat`
+*   `tf.data.Dataset.shard`
+*   `tf.data.Dataset.shuffle`
+*   `tf.data.Dataset.skip`
+*   `tf.data.Dataset.take`
 
 ### Custom transformation functions
 
-Custom transformation functions can be applied to a `Dataset` using @{tf.data.Dataset.apply}. Below are custom transformation functions from `tf.contrib.data`:
-
-*   @{tf.contrib.data.batch_and_drop_remainder}
-*   @{tf.contrib.data.dense_to_sparse_batch}
-*   @{tf.contrib.data.enumerate_dataset}
-*   @{tf.contrib.data.group_by_window}
-*   @{tf.contrib.data.ignore_errors}
-*   @{tf.contrib.data.map_and_batch}
-*   @{tf.contrib.data.padded_batch_and_drop_remainder}
-*   @{tf.contrib.data.parallel_interleave}
-*   @{tf.contrib.data.rejection_resample}
-*   @{tf.contrib.data.scan}
-*   @{tf.contrib.data.shuffle_and_repeat}
-*   @{tf.contrib.data.unbatch}
+Custom transformation functions can be applied to a `Dataset` using `tf.data.Dataset.apply`. Below are custom transformation functions from `tf.contrib.data`:
+
+*   `tf.contrib.data.batch_and_drop_remainder`
+*   `tf.contrib.data.dense_to_sparse_batch`
+*   `tf.contrib.data.enumerate_dataset`
+*   `tf.contrib.data.group_by_window`
+*   `tf.contrib.data.ignore_errors`
+*   `tf.contrib.data.map_and_batch`
+*   `tf.contrib.data.padded_batch_and_drop_remainder`
+*   `tf.contrib.data.parallel_interleave`
+*   `tf.contrib.data.rejection_resample`
+*   `tf.contrib.data.scan`
+*   `tf.contrib.data.shuffle_and_repeat`
+*   `tf.contrib.data.unbatch`
 
 ## Iterating over datasets
 
-These functions make a @{tf.data.Iterator} from a `Dataset`.
+These functions make a `tf.data.Iterator` from a `Dataset`.
 
-*   @{tf.data.Dataset.make_initializable_iterator}
-*   @{tf.data.Dataset.make_one_shot_iterator}
+*   `tf.data.Dataset.make_initializable_iterator`
+*   `tf.data.Dataset.make_one_shot_iterator`
 
-The `Iterator` class also contains static methods that create a @{tf.data.Iterator} that can be used with multiple `Dataset` objects.
+The `Iterator` class also contains static methods that create a `tf.data.Iterator` that can be used with multiple `Dataset` objects.
 
-*   @{tf.data.Iterator.from_structure}
-*   @{tf.data.Iterator.from_string_handle}
+*   `tf.data.Iterator.from_structure`
+*   `tf.data.Iterator.from_string_handle`
 
 ## Extra functions from `tf.contrib.data`
 
-*   @{tf.contrib.data.get_single_element}
-*   @{tf.contrib.data.make_saveable_from_iterator}
-*   @{tf.contrib.data.read_batch_features}
+*   `tf.contrib.data.get_single_element`
+*   `tf.contrib.data.make_saveable_from_iterator`
+*   `tf.contrib.data.read_batch_features`
 
diff --git a/api_guides/python/io_ops.md b/api_guides/python/io_ops.md
index 86b4b39..d7ce6fd 100644
--- a/api_guides/python/io_ops.md
+++ b/api_guides/python/io_ops.md
@@ -1,91 +1,91 @@
 # Inputs and Readers
 
 Note: Functions taking `Tensor` arguments can also take anything accepted by
-@{tf.convert_to_tensor}.
+`tf.convert_to_tensor`.
 
 [TOC]
 
 ## Placeholders
 
 TensorFlow provides a placeholder operation that must be fed with data
-on execution.  For more info, see the section on @{$reading_data#Feeding$Feeding data}.
+on execution.  For more info, see the section on [Feeding data](../../api_guides/python/reading_data.md#Feeding).
 
-*   @{tf.placeholder}
-*   @{tf.placeholder_with_default}
+*   `tf.placeholder`
+*   `tf.placeholder_with_default`
 
 For feeding `SparseTensor`s which are composite type,
 there is a convenience function:
 
-*   @{tf.sparse_placeholder}
+*   `tf.sparse_placeholder`
 
 ## Readers
 
 TensorFlow provides a set of Reader classes for reading data formats.
-For more information on inputs and readers, see @{$reading_data$Reading data}.
+For more information on inputs and readers, see [Reading data](../../api_guides/python/reading_data.md).
 
-*   @{tf.ReaderBase}
-*   @{tf.TextLineReader}
-*   @{tf.WholeFileReader}
-*   @{tf.IdentityReader}
-*   @{tf.TFRecordReader}
-*   @{tf.FixedLengthRecordReader}
+*   `tf.ReaderBase`
+*   `tf.TextLineReader`
+*   `tf.WholeFileReader`
+*   `tf.IdentityReader`
+*   `tf.TFRecordReader`
+*   `tf.FixedLengthRecordReader`
 
 ## Converting
 
 TensorFlow provides several operations that you can use to convert various data
 formats into tensors.
 
-*   @{tf.decode_csv}
-*   @{tf.decode_raw}
+*   `tf.decode_csv`
+*   `tf.decode_raw`
 
 - - -
 
 ### Example protocol buffer
 
-TensorFlow's @{$reading_data#standard_tensorflow_format$recommended format for training examples}
+TensorFlow's [recommended format for training examples](../../api_guides/python/reading_data.md#standard_tensorflow_format)
 is serialized `Example` protocol buffers, [described
 here](https://www.tensorflow.org/code/tensorflow/core/example/example.proto).
 They contain `Features`, [described
 here](https://www.tensorflow.org/code/tensorflow/core/example/feature.proto).
 
-*   @{tf.VarLenFeature}
-*   @{tf.FixedLenFeature}
-*   @{tf.FixedLenSequenceFeature}
-*   @{tf.SparseFeature}
-*   @{tf.parse_example}
-*   @{tf.parse_single_example}
-*   @{tf.parse_tensor}
-*   @{tf.decode_json_example}
+*   `tf.VarLenFeature`
+*   `tf.FixedLenFeature`
+*   `tf.FixedLenSequenceFeature`
+*   `tf.SparseFeature`
+*   `tf.parse_example`
+*   `tf.parse_single_example`
+*   `tf.parse_tensor`
+*   `tf.decode_json_example`
 
 ## Queues
 
 TensorFlow provides several implementations of 'Queues', which are
 structures within the TensorFlow computation graph to stage pipelines
 of tensors together. The following describe the basic Queue interface
-and some implementations.  To see an example use, see @{$threading_and_queues$Threading and Queues}.
+and some implementations.  To see an example use, see [Threading and Queues](../../api_guides/python/threading_and_queues.md).
 
-*   @{tf.QueueBase}
-*   @{tf.FIFOQueue}
-*   @{tf.PaddingFIFOQueue}
-*   @{tf.RandomShuffleQueue}
-*   @{tf.PriorityQueue}
+*   `tf.QueueBase`
+*   `tf.FIFOQueue`
+*   `tf.PaddingFIFOQueue`
+*   `tf.RandomShuffleQueue`
+*   `tf.PriorityQueue`
 
 ## Conditional Accumulators
 
-*   @{tf.ConditionalAccumulatorBase}
-*   @{tf.ConditionalAccumulator}
-*   @{tf.SparseConditionalAccumulator}
+*   `tf.ConditionalAccumulatorBase`
+*   `tf.ConditionalAccumulator`
+*   `tf.SparseConditionalAccumulator`
 
 ## Dealing with the filesystem
 
-*   @{tf.matching_files}
-*   @{tf.read_file}
-*   @{tf.write_file}
+*   `tf.matching_files`
+*   `tf.read_file`
+*   `tf.write_file`
 
 ## Input pipeline
 
 TensorFlow functions for setting up an input-prefetching pipeline.
-Please see the @{$reading_data$reading data how-to}
+Please see the [reading data how-to](../../api_guides/python/reading_data.md)
 for context.
 
 ### Beginning of an input pipeline
@@ -93,12 +93,12 @@ for context.
 The "producer" functions add a queue to the graph and a corresponding
 `QueueRunner` for running the subgraph that fills that queue.
 
-*   @{tf.train.match_filenames_once}
-*   @{tf.train.limit_epochs}
-*   @{tf.train.input_producer}
-*   @{tf.train.range_input_producer}
-*   @{tf.train.slice_input_producer}
-*   @{tf.train.string_input_producer}
+*   `tf.train.match_filenames_once`
+*   `tf.train.limit_epochs`
+*   `tf.train.input_producer`
+*   `tf.train.range_input_producer`
+*   `tf.train.slice_input_producer`
+*   `tf.train.string_input_producer`
 
 ### Batching at the end of an input pipeline
 
@@ -106,25 +106,25 @@ These functions add a queue to the graph to assemble a batch of
 examples, with possible shuffling.  They also add a `QueueRunner` for
 running the subgraph that fills that queue.
 
-Use @{tf.train.batch} or @{tf.train.batch_join} for batching
+Use `tf.train.batch` or `tf.train.batch_join` for batching
 examples that have already been well shuffled.  Use
-@{tf.train.shuffle_batch} or
-@{tf.train.shuffle_batch_join} for examples that would
+`tf.train.shuffle_batch` or
+`tf.train.shuffle_batch_join` for examples that would
 benefit from additional shuffling.
 
-Use @{tf.train.batch} or @{tf.train.shuffle_batch} if you want a
+Use `tf.train.batch` or `tf.train.shuffle_batch` if you want a
 single thread producing examples to batch, or if you have a
 single subgraph producing examples but you want to run it in *N* threads
 (where you increase *N* until it can keep the queue full).  Use
-@{tf.train.batch_join} or @{tf.train.shuffle_batch_join}
+`tf.train.batch_join` or `tf.train.shuffle_batch_join`
 if you have *N* different subgraphs producing examples to batch and you
 want them run by *N* threads. Use `maybe_*` to enqueue conditionally.
 
-*   @{tf.train.batch}
-*   @{tf.train.maybe_batch}
-*   @{tf.train.batch_join}
-*   @{tf.train.maybe_batch_join}
-*   @{tf.train.shuffle_batch}
-*   @{tf.train.maybe_shuffle_batch}
-*   @{tf.train.shuffle_batch_join}
-*   @{tf.train.maybe_shuffle_batch_join}
+*   `tf.train.batch`
+*   `tf.train.maybe_batch`
+*   `tf.train.batch_join`
+*   `tf.train.maybe_batch_join`
+*   `tf.train.shuffle_batch`
+*   `tf.train.maybe_shuffle_batch`
+*   `tf.train.shuffle_batch_join`
+*   `tf.train.maybe_shuffle_batch_join`
diff --git a/api_guides/python/math_ops.md b/api_guides/python/math_ops.md
index dee7f16..6ec18f4 100644
--- a/api_guides/python/math_ops.md
+++ b/api_guides/python/math_ops.md
@@ -1,7 +1,7 @@
 # Math
 
 Note: Functions taking `Tensor` arguments can also take anything accepted by
-@{tf.convert_to_tensor}.
+`tf.convert_to_tensor`.
 
 [TOC]
 
@@ -13,97 +13,98 @@ broadcasting](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html).
 TensorFlow provides several operations that you can use to add basic arithmetic
 operators to your graph.
 
-*   @{tf.add}
-*   @{tf.subtract}
-*   @{tf.multiply}
-*   @{tf.scalar_mul}
-*   @{tf.div}
-*   @{tf.divide}
-*   @{tf.truediv}
-*   @{tf.floordiv}
-*   @{tf.realdiv}
-*   @{tf.truncatediv}
-*   @{tf.floor_div}
-*   @{tf.truncatemod}
-*   @{tf.floormod}
-*   @{tf.mod}
-*   @{tf.cross}
+*   `tf.add`
+*   `tf.subtract`
+*   `tf.multiply`
+*   `tf.scalar_mul`
+*   `tf.div`
+*   `tf.divide`
+*   `tf.truediv`
+*   `tf.floordiv`
+*   `tf.realdiv`
+*   `tf.truncatediv`
+*   `tf.floor_div`
+*   `tf.div_no_nan`
+*   `tf.truncatemod`
+*   `tf.floormod`
+*   `tf.mod`
+*   `tf.cross`
 
 ## Basic Math Functions
 
 TensorFlow provides several operations that you can use to add basic
 mathematical functions to your graph.
 
-*   @{tf.add_n}
-*   @{tf.abs}
-*   @{tf.negative}
-*   @{tf.sign}
-*   @{tf.reciprocal}
-*   @{tf.square}
-*   @{tf.round}
-*   @{tf.sqrt}
-*   @{tf.rsqrt}
-*   @{tf.pow}
-*   @{tf.exp}
-*   @{tf.expm1}
-*   @{tf.log}
-*   @{tf.log1p}
-*   @{tf.ceil}
-*   @{tf.floor}
-*   @{tf.maximum}
-*   @{tf.minimum}
-*   @{tf.cos}
-*   @{tf.sin}
-*   @{tf.lbeta}
-*   @{tf.tan}
-*   @{tf.acos}
-*   @{tf.asin}
-*   @{tf.atan}
-*   @{tf.cosh}
-*   @{tf.sinh}
-*   @{tf.asinh}
-*   @{tf.acosh}
-*   @{tf.atanh}
-*   @{tf.lgamma}
-*   @{tf.digamma}
-*   @{tf.erf}
-*   @{tf.erfc}
-*   @{tf.squared_difference}
-*   @{tf.igamma}
-*   @{tf.igammac}
-*   @{tf.zeta}
-*   @{tf.polygamma}
-*   @{tf.betainc}
-*   @{tf.rint}
+*   `tf.add_n`
+*   `tf.abs`
+*   `tf.negative`
+*   `tf.sign`
+*   `tf.reciprocal`
+*   `tf.square`
+*   `tf.round`
+*   `tf.sqrt`
+*   `tf.rsqrt`
+*   `tf.pow`
+*   `tf.exp`
+*   `tf.expm1`
+*   `tf.log`
+*   `tf.log1p`
+*   `tf.ceil`
+*   `tf.floor`
+*   `tf.maximum`
+*   `tf.minimum`
+*   `tf.cos`
+*   `tf.sin`
+*   `tf.lbeta`
+*   `tf.tan`
+*   `tf.acos`
+*   `tf.asin`
+*   `tf.atan`
+*   `tf.cosh`
+*   `tf.sinh`
+*   `tf.asinh`
+*   `tf.acosh`
+*   `tf.atanh`
+*   `tf.lgamma`
+*   `tf.digamma`
+*   `tf.erf`
+*   `tf.erfc`
+*   `tf.squared_difference`
+*   `tf.igamma`
+*   `tf.igammac`
+*   `tf.zeta`
+*   `tf.polygamma`
+*   `tf.betainc`
+*   `tf.rint`
 
 ## Matrix Math Functions
 
 TensorFlow provides several operations that you can use to add linear algebra
 functions on matrices to your graph.
 
-*   @{tf.diag}
-*   @{tf.diag_part}
-*   @{tf.trace}
-*   @{tf.transpose}
-*   @{tf.eye}
-*   @{tf.matrix_diag}
-*   @{tf.matrix_diag_part}
-*   @{tf.matrix_band_part}
-*   @{tf.matrix_set_diag}
-*   @{tf.matrix_transpose}
-*   @{tf.matmul}
-*   @{tf.norm}
-*   @{tf.matrix_determinant}
-*   @{tf.matrix_inverse}
-*   @{tf.cholesky}
-*   @{tf.cholesky_solve}
-*   @{tf.matrix_solve}
-*   @{tf.matrix_triangular_solve}
-*   @{tf.matrix_solve_ls}
-*   @{tf.qr}
-*   @{tf.self_adjoint_eig}
-*   @{tf.self_adjoint_eigvals}
-*   @{tf.svd}
+*   `tf.diag`
+*   `tf.diag_part`
+*   `tf.trace`
+*   `tf.transpose`
+*   `tf.eye`
+*   `tf.matrix_diag`
+*   `tf.matrix_diag_part`
+*   `tf.matrix_band_part`
+*   `tf.matrix_set_diag`
+*   `tf.matrix_transpose`
+*   `tf.matmul`
+*   `tf.norm`
+*   `tf.matrix_determinant`
+*   `tf.matrix_inverse`
+*   `tf.cholesky`
+*   `tf.cholesky_solve`
+*   `tf.matrix_solve`
+*   `tf.matrix_triangular_solve`
+*   `tf.matrix_solve_ls`
+*   `tf.qr`
+*   `tf.self_adjoint_eig`
+*   `tf.self_adjoint_eigvals`
+*   `tf.svd`
 
 
 ## Tensor Math Function
@@ -111,7 +112,7 @@ functions on matrices to your graph.
 TensorFlow provides operations that you can use to add tensor functions to your
 graph.
 
-*   @{tf.tensordot}
+*   `tf.tensordot`
 
 
 ## Complex Number Functions
@@ -119,11 +120,11 @@ graph.
 TensorFlow provides several operations that you can use to add complex number
 functions to your graph.
 
-*   @{tf.complex}
-*   @{tf.conj}
-*   @{tf.imag}
-*   @{tf.angle}
-*   @{tf.real}
+*   `tf.complex`
+*   `tf.conj`
+*   `tf.imag`
+*   `tf.angle`
+*   `tf.real`
 
 
 ## Reduction
@@ -131,25 +132,25 @@ functions to your graph.
 TensorFlow provides several operations that you can use to perform
 common math computations that reduce various dimensions of a tensor.
 
-*   @{tf.reduce_sum}
-*   @{tf.reduce_prod}
-*   @{tf.reduce_min}
-*   @{tf.reduce_max}
-*   @{tf.reduce_mean}
-*   @{tf.reduce_all}
-*   @{tf.reduce_any}
-*   @{tf.reduce_logsumexp}
-*   @{tf.count_nonzero}
-*   @{tf.accumulate_n}
-*   @{tf.einsum}
+*   `tf.reduce_sum`
+*   `tf.reduce_prod`
+*   `tf.reduce_min`
+*   `tf.reduce_max`
+*   `tf.reduce_mean`
+*   `tf.reduce_all`
+*   `tf.reduce_any`
+*   `tf.reduce_logsumexp`
+*   `tf.count_nonzero`
+*   `tf.accumulate_n`
+*   `tf.einsum`
 
 ## Scan
 
 TensorFlow provides several operations that you can use to perform scans
 (running totals) across one axis of a tensor.
 
-*   @{tf.cumsum}
-*   @{tf.cumprod}
+*   `tf.cumsum`
+*   `tf.cumprod`
 
 ## Segmentation
 
@@ -172,15 +173,15 @@ tf.segment_sum(c, tf.constant([0, 0, 1]))
         [5 6 7 8]]
 ```
 
-*   @{tf.segment_sum}
-*   @{tf.segment_prod}
-*   @{tf.segment_min}
-*   @{tf.segment_max}
-*   @{tf.segment_mean}
-*   @{tf.unsorted_segment_sum}
-*   @{tf.sparse_segment_sum}
-*   @{tf.sparse_segment_mean}
-*   @{tf.sparse_segment_sqrt_n}
+*   `tf.segment_sum`
+*   `tf.segment_prod`
+*   `tf.segment_min`
+*   `tf.segment_max`
+*   `tf.segment_mean`
+*   `tf.unsorted_segment_sum`
+*   `tf.sparse_segment_sum`
+*   `tf.sparse_segment_mean`
+*   `tf.sparse_segment_sqrt_n`
 
 
 ## Sequence Comparison and Indexing
@@ -190,10 +191,10 @@ comparison and index extraction to your graph. You can use these operations to
 determine sequence differences and determine the indexes of specific values in
 a tensor.
 
-*   @{tf.argmin}
-*   @{tf.argmax}
-*   @{tf.setdiff1d}
-*   @{tf.where}
-*   @{tf.unique}
-*   @{tf.edit_distance}
-*   @{tf.invert_permutation}
+*   `tf.argmin`
+*   `tf.argmax`
+*   `tf.setdiff1d`
+*   `tf.where`
+*   `tf.unique`
+*   `tf.edit_distance`
+*   `tf.invert_permutation`
diff --git a/api_guides/python/meta_graph.md b/api_guides/python/meta_graph.md
index 0eff900..5e8a8b4 100644
--- a/api_guides/python/meta_graph.md
+++ b/api_guides/python/meta_graph.md
@@ -7,10 +7,10 @@ term storage of graphs.  The MetaGraph contains the information required
 to continue training, perform evaluation, or run inference on a previously trained graph.
 
 The APIs for exporting and importing the complete model are in
-the @{tf.train.Saver} class:
-@{tf.train.export_meta_graph}
+the `tf.train.Saver` class:
+`tf.train.export_meta_graph`
 and
-@{tf.train.import_meta_graph}.
+`tf.train.import_meta_graph`.
 
 ## What's in a MetaGraph
 
@@ -22,14 +22,14 @@ protocol buffer. It contains the following fields:
 * [`GraphDef`](https://www.tensorflow.org/code/tensorflow/core/framework/graph.proto) for describing the graph.
 * [`SaverDef`](https://www.tensorflow.org/code/tensorflow/core/protobuf/saver.proto) for the saver.
 * [`CollectionDef`](https://www.tensorflow.org/code/tensorflow/core/protobuf/meta_graph.proto)
-map that further describes additional components of the model, such as
-@{$python/state_ops$`Variables`},
-@{tf.train.QueueRunner}, etc.  In order for a Python object to be serialized
+map that further describes additional components of the model such as
+[`Variables`](../../api_guides/python/state_ops.md),
+`tf.train.QueueRunner`, etc.
+
+In order for a Python object to be serialized
 to and from `MetaGraphDef`, the Python class must implement `to_proto()` and
 `from_proto()` methods, and register them with the system using
-`register_proto_function`.
-
-  For example,
+`register_proto_function`. For example:
 
   ```Python
   def to_proto(self, export_scope=None):
@@ -122,7 +122,7 @@ The API for exporting a running model as a MetaGraph is `export_meta_graph()`.
 
 
 The MetaGraph is also automatically exported via the `save()` API in
-@{tf.train.Saver}.
+`tf.train.Saver`.
 
 
 ## Import a MetaGraph
diff --git a/api_guides/python/nn.md b/api_guides/python/nn.md
index 8d8daaa..40dda39 100644
--- a/api_guides/python/nn.md
+++ b/api_guides/python/nn.md
@@ -1,7 +1,7 @@
 # Neural Network
 
 Note: Functions taking `Tensor` arguments can also take anything accepted by
-@{tf.convert_to_tensor}.
+`tf.convert_to_tensor`.
 
 [TOC]
 
@@ -16,17 +16,17 @@ functions (`relu`, `relu6`, `crelu` and `relu_x`), and random regularization
 All activation ops apply componentwise, and produce a tensor of the same
 shape as the input tensor.
 
-*   @{tf.nn.relu}
-*   @{tf.nn.relu6}
-*   @{tf.nn.crelu}
-*   @{tf.nn.elu}
-*   @{tf.nn.selu}
-*   @{tf.nn.softplus}
-*   @{tf.nn.softsign}
-*   @{tf.nn.dropout}
-*   @{tf.nn.bias_add}
-*   @{tf.sigmoid}
-*   @{tf.tanh}
+*   `tf.nn.relu`
+*   `tf.nn.relu6`
+*   `tf.nn.crelu`
+*   `tf.nn.elu`
+*   `tf.nn.selu`
+*   `tf.nn.softplus`
+*   `tf.nn.softsign`
+*   `tf.nn.dropout`
+*   `tf.nn.bias_add`
+*   `tf.sigmoid`
+*   `tf.tanh`
 
 ## Convolution
 
@@ -112,22 +112,22 @@ vectors.  For `depthwise_conv_2d`, each scalar component `input[b, i, j, k]`
 is multiplied by a vector `filter[di, dj, k]`, and all the vectors are
 concatenated.
 
-*   @{tf.nn.convolution}
-*   @{tf.nn.conv2d}
-*   @{tf.nn.depthwise_conv2d}
-*   @{tf.nn.depthwise_conv2d_native}
-*   @{tf.nn.separable_conv2d}
-*   @{tf.nn.atrous_conv2d}
-*   @{tf.nn.atrous_conv2d_transpose}
-*   @{tf.nn.conv2d_transpose}
-*   @{tf.nn.conv1d}
-*   @{tf.nn.conv3d}
-*   @{tf.nn.conv3d_transpose}
-*   @{tf.nn.conv2d_backprop_filter}
-*   @{tf.nn.conv2d_backprop_input}
-*   @{tf.nn.conv3d_backprop_filter_v2}
-*   @{tf.nn.depthwise_conv2d_native_backprop_filter}
-*   @{tf.nn.depthwise_conv2d_native_backprop_input}
+*   `tf.nn.convolution`
+*   `tf.nn.conv2d`
+*   `tf.nn.depthwise_conv2d`
+*   `tf.nn.depthwise_conv2d_native`
+*   `tf.nn.separable_conv2d`
+*   `tf.nn.atrous_conv2d`
+*   `tf.nn.atrous_conv2d_transpose`
+*   `tf.nn.conv2d_transpose`
+*   `tf.nn.conv1d`
+*   `tf.nn.conv3d`
+*   `tf.nn.conv3d_transpose`
+*   `tf.nn.conv2d_backprop_filter`
+*   `tf.nn.conv2d_backprop_input`
+*   `tf.nn.conv3d_backprop_filter_v2`
+*   `tf.nn.depthwise_conv2d_native_backprop_filter`
+*   `tf.nn.depthwise_conv2d_native_backprop_input`
 
 ## Pooling
 
@@ -144,14 +144,14 @@ In detail, the output is
 where the indices also take into consideration the padding values. Please refer
 to the `Convolution` section for details about the padding calculation.
 
-*   @{tf.nn.avg_pool}
-*   @{tf.nn.max_pool}
-*   @{tf.nn.max_pool_with_argmax}
-*   @{tf.nn.avg_pool3d}
-*   @{tf.nn.max_pool3d}
-*   @{tf.nn.fractional_avg_pool}
-*   @{tf.nn.fractional_max_pool}
-*   @{tf.nn.pool}
+*   `tf.nn.avg_pool`
+*   `tf.nn.max_pool`
+*   `tf.nn.max_pool_with_argmax`
+*   `tf.nn.avg_pool3d`
+*   `tf.nn.max_pool3d`
+*   `tf.nn.fractional_avg_pool`
+*   `tf.nn.fractional_max_pool`
+*   `tf.nn.pool`
 
 ## Morphological filtering
 
@@ -190,24 +190,24 @@ Dilation and erosion are dual to each other. The dilation of the input signal
 Striding and padding is carried out in exactly the same way as in standard
 convolution. Please refer to the `Convolution` section for details.
 
-*   @{tf.nn.dilation2d}
-*   @{tf.nn.erosion2d}
-*   @{tf.nn.with_space_to_batch}
+*   `tf.nn.dilation2d`
+*   `tf.nn.erosion2d`
+*   `tf.nn.with_space_to_batch`
 
 ## Normalization
 
 Normalization is useful to prevent neurons from saturating when inputs may
 have varying scale, and to aid generalization.
 
-*   @{tf.nn.l2_normalize}
-*   @{tf.nn.local_response_normalization}
-*   @{tf.nn.sufficient_statistics}
-*   @{tf.nn.normalize_moments}
-*   @{tf.nn.moments}
-*   @{tf.nn.weighted_moments}
-*   @{tf.nn.fused_batch_norm}
-*   @{tf.nn.batch_normalization}
-*   @{tf.nn.batch_norm_with_global_normalization}
+*   `tf.nn.l2_normalize`
+*   `tf.nn.local_response_normalization`
+*   `tf.nn.sufficient_statistics`
+*   `tf.nn.normalize_moments`
+*   `tf.nn.moments`
+*   `tf.nn.weighted_moments`
+*   `tf.nn.fused_batch_norm`
+*   `tf.nn.batch_normalization`
+*   `tf.nn.batch_norm_with_global_normalization`
 
 ## Losses
 
@@ -215,29 +215,29 @@ The loss ops measure error between two tensors, or between a tensor and zero.
 These can be used for measuring accuracy of a network in a regression task
 or for regularization purposes (weight decay).
 
-*   @{tf.nn.l2_loss}
-*   @{tf.nn.log_poisson_loss}
+*   `tf.nn.l2_loss`
+*   `tf.nn.log_poisson_loss`
 
 ## Classification
 
 TensorFlow provides several operations that help you perform classification.
 
-*   @{tf.nn.sigmoid_cross_entropy_with_logits}
-*   @{tf.nn.softmax}
-*   @{tf.nn.log_softmax}
-*   @{tf.nn.softmax_cross_entropy_with_logits}
-*   @{tf.nn.softmax_cross_entropy_with_logits_v2} - identical to the base
+*   `tf.nn.sigmoid_cross_entropy_with_logits`
+*   `tf.nn.softmax`
+*   `tf.nn.log_softmax`
+*   `tf.nn.softmax_cross_entropy_with_logits`
+*   `tf.nn.softmax_cross_entropy_with_logits_v2` - identical to the base
     version, except it allows gradient propagation into the labels.
-*   @{tf.nn.sparse_softmax_cross_entropy_with_logits}
-*   @{tf.nn.weighted_cross_entropy_with_logits}
+*   `tf.nn.sparse_softmax_cross_entropy_with_logits`
+*   `tf.nn.weighted_cross_entropy_with_logits`
 
 ## Embeddings
 
 TensorFlow provides library support for looking up values in embedding
 tensors.
 
-*   @{tf.nn.embedding_lookup}
-*   @{tf.nn.embedding_lookup_sparse}
+*   `tf.nn.embedding_lookup`
+*   `tf.nn.embedding_lookup_sparse`
 
 ## Recurrent Neural Networks
 
@@ -245,23 +245,23 @@ TensorFlow provides a number of methods for constructing Recurrent
 Neural Networks.  Most accept an `RNNCell`-subclassed object
 (see the documentation for `tf.contrib.rnn`).
 
-*   @{tf.nn.dynamic_rnn}
-*   @{tf.nn.bidirectional_dynamic_rnn}
-*   @{tf.nn.raw_rnn}
+*   `tf.nn.dynamic_rnn`
+*   `tf.nn.bidirectional_dynamic_rnn`
+*   `tf.nn.raw_rnn`
 
 ## Connectionist Temporal Classification (CTC)
 
-*   @{tf.nn.ctc_loss}
-*   @{tf.nn.ctc_greedy_decoder}
-*   @{tf.nn.ctc_beam_search_decoder}
+*   `tf.nn.ctc_loss`
+*   `tf.nn.ctc_greedy_decoder`
+*   `tf.nn.ctc_beam_search_decoder`
 
 ## Evaluation
 
 The evaluation ops are useful for measuring the performance of a network.
 They are typically used at evaluation time.
 
-*   @{tf.nn.top_k}
-*   @{tf.nn.in_top_k}
+*   `tf.nn.top_k`
+*   `tf.nn.in_top_k`
 
 ## Candidate Sampling
 
@@ -281,29 +281,29 @@ Reference](https://www.tensorflow.org/extras/candidate_sampling.pdf)
 
 TensorFlow provides the following sampled loss functions for faster training.
 
-*   @{tf.nn.nce_loss}
-*   @{tf.nn.sampled_softmax_loss}
+*   `tf.nn.nce_loss`
+*   `tf.nn.sampled_softmax_loss`
 
 ### Candidate Samplers
 
 TensorFlow provides the following samplers for randomly sampling candidate
 classes when using one of the sampled loss functions above.
 
-*   @{tf.nn.uniform_candidate_sampler}
-*   @{tf.nn.log_uniform_candidate_sampler}
-*   @{tf.nn.learned_unigram_candidate_sampler}
-*   @{tf.nn.fixed_unigram_candidate_sampler}
+*   `tf.nn.uniform_candidate_sampler`
+*   `tf.nn.log_uniform_candidate_sampler`
+*   `tf.nn.learned_unigram_candidate_sampler`
+*   `tf.nn.fixed_unigram_candidate_sampler`
 
 ### Miscellaneous candidate sampling utilities
 
-*   @{tf.nn.compute_accidental_hits}
+*   `tf.nn.compute_accidental_hits`
 
 ### Quantization ops
 
-*   @{tf.nn.quantized_conv2d}
-*   @{tf.nn.quantized_relu_x}
-*   @{tf.nn.quantized_max_pool}
-*   @{tf.nn.quantized_avg_pool}
+*   `tf.nn.quantized_conv2d`
+*   `tf.nn.quantized_relu_x`
+*   `tf.nn.quantized_max_pool`
+*   `tf.nn.quantized_avg_pool`
 
 ## Notes on SAME Convolution Padding
 
diff --git a/api_guides/python/python_io.md b/api_guides/python/python_io.md
index 06282e4..e7e82a8 100644
--- a/api_guides/python/python_io.md
+++ b/api_guides/python/python_io.md
@@ -5,10 +5,10 @@ A TFRecords file represents a sequence of (binary) strings.  The format is not
 random access, so it is suitable for streaming large amounts of data but not
 suitable if fast sharding or other non-sequential access is desired.
 
-*   @{tf.python_io.TFRecordWriter}
-*   @{tf.python_io.tf_record_iterator}
-*   @{tf.python_io.TFRecordCompressionType}
-*   @{tf.python_io.TFRecordOptions}
+*   `tf.python_io.TFRecordWriter`
+*   `tf.python_io.tf_record_iterator`
+*   `tf.python_io.TFRecordCompressionType`
+*   `tf.python_io.TFRecordOptions`
 
 - - -
 
diff --git a/api_guides/python/reading_data.md b/api_guides/python/reading_data.md
index b3ca958..9f555ee 100644
--- a/api_guides/python/reading_data.md
+++ b/api_guides/python/reading_data.md
@@ -1,7 +1,7 @@
 # Reading data
 
 Note: The preferred way to feed data into a tensorflow program is using the
-@{$datasets$`tf.data` API}.
+[`tf.data` API](../../guide/datasets.md).
 
 There are four methods of getting data into a TensorFlow program:
 
@@ -16,8 +16,8 @@ There are four methods of getting data into a TensorFlow program:
 
 ## `tf.data` API
 
-See the @{$datasets$programmer's guide} for an in-depth explanation of
-@{tf.data.Dataset}. The `tf.data` API enables you to extract and preprocess data
+See the [Importing Data](../../guide/datasets.md) for an in-depth explanation of `tf.data.Dataset`.
+The `tf.data` API enables you to extract and preprocess data
 from different input/file formats, and apply transformations such as batching,
 shuffling, and mapping functions over the dataset. This is an improved version
 of the old input methods---feeding and `QueueRunner`---which are described
@@ -44,7 +44,7 @@ with tf.Session():
 
 While you can replace any Tensor with feed data, including variables and
 constants, the best practice is to use a
-@{tf.placeholder} node. A
+`tf.placeholder` node. A
 `placeholder` exists solely to serve as the target of feeds. It is not
 initialized and contains no data. A placeholder generates an error if
 it is executed without a feed, so you won't forget to feed it.
@@ -56,8 +56,8 @@ in
 ## `QueueRunner`
 
 Warning: This section discusses implementing input pipelines using the
-queue-based APIs which can be cleanly replaced by the @{$datasets$`tf.data`
-API}.
+queue-based APIs which can be cleanly replaced by the [`tf.data`
+API](../../guide/datasets.md).
 
 A typical queue-based pipeline for reading records from files has the following stages:
 
@@ -74,9 +74,9 @@ A typical queue-based pipeline for reading records from files has the following
 
 For the list of filenames, use either a constant string Tensor (like
 `["file0", "file1"]` or `[("file%d" % i) for i in range(2)]`) or the
-@{tf.train.match_filenames_once} function.
+`tf.train.match_filenames_once` function.
 
-Pass the list of filenames to the @{tf.train.string_input_producer} function.
+Pass the list of filenames to the `tf.train.string_input_producer` function.
 `string_input_producer` creates a FIFO queue for holding the filenames until
 the reader needs them.
 
@@ -102,8 +102,8 @@ decode this string into the tensors that make up an example.
 
 To read text files in [comma-separated value (CSV)
 format](https://tools.ietf.org/html/rfc4180), use a
-@{tf.TextLineReader} with the
-@{tf.decode_csv} operation. For example:
+`tf.TextLineReader` with the
+`tf.decode_csv` operation. For example:
 
 ```python
 filename_queue = tf.train.string_input_producer(["file0.csv", "file1.csv"])
@@ -143,8 +143,8 @@ block while it waits for filenames from the queue.
 #### Fixed length records
 
 To read binary files in which each record is a fixed number of bytes, use
-@{tf.FixedLengthRecordReader}
-with the @{tf.decode_raw} operation.
+`tf.FixedLengthRecordReader`
+with the `tf.decode_raw` operation.
 The `decode_raw` op converts from a string to a uint8 tensor.
 
 For example, [the CIFAR-10 dataset](http://www.cs.toronto.edu/~kriz/cifar.html)
@@ -154,14 +154,14 @@ a uint8 tensor, standard operations can slice out each piece and reformat as
 needed. For CIFAR-10, you can see how to do the reading and decoding in
 [`tensorflow_models/tutorials/image/cifar10/cifar10_input.py`](https://github.com/tensorflow/models/tree/master/tutorials/image/cifar10/cifar10_input.py)
 and described in
-@{$deep_cnn#prepare-the-data$this tutorial}.
+[this tutorial](../../tutorials/images/deep_cnn.md#prepare-the-data).
 
 #### Standard TensorFlow format
 
 Another approach is to convert whatever data you have into a supported format.
 This approach makes it easier to mix and match data sets and network
 architectures. The recommended format for TensorFlow is a
-@{$python/python_io#tfrecords_format_details$TFRecords file}
+[TFRecords file](../../api_guides/python/python_io.md#tfrecords_format_details)
 containing
 [`tf.train.Example` protocol buffers](https://www.tensorflow.org/code/tensorflow/core/example/example.proto)
 (which contain
@@ -169,12 +169,12 @@ containing
 as a field).  You write a little program that gets your data, stuffs it in an
 `Example` protocol buffer, serializes the protocol buffer to a string, and then
 writes the string to a TFRecords file using the
-@{tf.python_io.TFRecordWriter}.
+`tf.python_io.TFRecordWriter`.
 For example,
 [`tensorflow/examples/how_tos/reading_data/convert_to_records.py`](https://www.tensorflow.org/code/tensorflow/examples/how_tos/reading_data/convert_to_records.py)
 converts MNIST data to this format.
 
-The recommended way to read a TFRecord file is with a @{tf.data.TFRecordDataset}, [as in this example](https://www.tensorflow.org/code/tensorflow/examples/how_tos/reading_data/fully_connected_reader.py):
+The recommended way to read a TFRecord file is with a `tf.data.TFRecordDataset`, [as in this example](https://www.tensorflow.org/code/tensorflow/examples/how_tos/reading_data/fully_connected_reader.py):
 
 ``` python
     dataset = tf.data.TFRecordDataset(filename)
@@ -184,7 +184,7 @@ The recommended way to read a TFRecord file is with a @{tf.data.TFRecordDataset}
     dataset = dataset.map(decode)
 ```
 
-To acomplish the same task with a queue based input pipeline requires the following code 
+To accomplish the same task with a queue based input pipeline requires the following code
 (using the same `decode` function from the above example): 
 
 ``` python
@@ -208,7 +208,7 @@ for an example.
 At the end of the pipeline we use another queue to batch together examples for
 training, evaluation, or inference.  For this we use a queue that randomizes the
 order of examples, using the
-@{tf.train.shuffle_batch}.
+`tf.train.shuffle_batch`.
 
 Example:
 
@@ -240,7 +240,7 @@ def input_pipeline(filenames, batch_size, num_epochs=None):
 
 If you need more parallelism or shuffling of examples between files, use
 multiple reader instances using the
-@{tf.train.shuffle_batch_join}.
+`tf.train.shuffle_batch_join`.
 For example:
 
 ```
@@ -266,7 +266,7 @@ epoch until all the files from the epoch have been started.  (It is also usually
 sufficient to have a single thread filling the filename queue.)
 
 An alternative is to use a single reader via the
-@{tf.train.shuffle_batch}
+`tf.train.shuffle_batch`
 with `num_threads` bigger than 1.  This will make it read from a single file at
 the same time (but faster than with 1 thread), instead of N files at once.
 This can be important:
@@ -279,18 +279,18 @@ This can be important:
 How many threads do you need? the `tf.train.shuffle_batch*` functions add a
 summary to the graph that indicates how full the example queue is. If you have
 enough reading threads, that summary will stay above zero.  You can
-@{$summaries_and_tensorboard$view your summaries as training progresses using TensorBoard}.
+[view your summaries as training progresses using TensorBoard](../../guide/summaries_and_tensorboard.md).
 
 ### Creating threads to prefetch using `QueueRunner` objects
 
 The short version: many of the `tf.train` functions listed above add
-@{tf.train.QueueRunner} objects to your
+`tf.train.QueueRunner` objects to your
 graph.  These require that you call
-@{tf.train.start_queue_runners}
+`tf.train.start_queue_runners`
 before running any training or inference steps, or it will hang forever. This
 will start threads that run the input pipeline, filling the example queue so
 that the dequeue to get the examples will succeed.  This is best combined with a
-@{tf.train.Coordinator} to cleanly
+`tf.train.Coordinator` to cleanly
 shut down these threads when there are errors. If you set a limit on the number
 of epochs, that will use an epoch counter that will need to be initialized. The
 recommended code pattern combining these is:
@@ -343,32 +343,32 @@ queue.
 </div>
 
 The helpers in `tf.train` that create these queues and enqueuing operations add
-a @{tf.train.QueueRunner} to the
+a `tf.train.QueueRunner` to the
 graph using the
-@{tf.train.add_queue_runner}
+`tf.train.add_queue_runner`
 function. Each `QueueRunner` is responsible for one stage, and holds the list of
 enqueue operations that need to be run in threads. Once the graph is
 constructed, the
-@{tf.train.start_queue_runners}
+`tf.train.start_queue_runners`
 function asks each QueueRunner in the graph to start its threads running the
 enqueuing operations.
 
 If all goes well, you can now run your training steps and the queues will be
 filled by the background threads. If you have set an epoch limit, at some point
 an attempt to dequeue examples will get an
-@{tf.errors.OutOfRangeError}. This
+`tf.errors.OutOfRangeError`. This
 is the TensorFlow equivalent of "end of file" (EOF) -- this means the epoch
 limit has been reached and no more examples are available.
 
 The last ingredient is the
-@{tf.train.Coordinator}. This is responsible
+`tf.train.Coordinator`. This is responsible
 for letting all the threads know if anything has signaled a shut down. Most
 commonly this would be because an exception was raised, for example one of the
 threads got an error when running some operation (or an ordinary Python
 exception).
 
 For more about threading, queues, QueueRunners, and Coordinators
-@{$threading_and_queues$see here}.
+[see here](../../api_guides/python/threading_and_queues.md).
 
 #### Aside: How clean shut-down when limiting epochs works
 
@@ -396,21 +396,21 @@ associated with a single QueueRunner.  If this isn't the last thread in the
 QueueRunner, the `OutOfRange` error just causes the one thread to exit.  This
 allows the other threads, which are still finishing up their last file, to
 proceed until they finish as well.  (Assuming you are using a
-@{tf.train.Coordinator},
+`tf.train.Coordinator`,
 other types of errors will cause all the threads to stop.)  Once all the reader
 threads hit the `OutOfRange` error, only then does the next queue, the example
 queue, gets closed.
 
 Again, the example queue will have some elements queued, so training will
 continue until those are exhausted.  If the example queue is a
-@{tf.RandomShuffleQueue}, say
+`tf.RandomShuffleQueue`, say
 because you are using `shuffle_batch` or `shuffle_batch_join`, it normally will
 avoid ever having fewer than its `min_after_dequeue` attr elements buffered.
 However, once the queue is closed that restriction will be lifted and the queue
 will eventually empty.  At that point the actual training threads, when they
 try and dequeue from example queue, will start getting `OutOfRange` errors and
 exiting.  Once all the training threads are done,
-@{tf.train.Coordinator.join}
+`tf.train.Coordinator.join`
 will return and you can exit cleanly.
 
 ### Filtering records or producing multiple examples per record
@@ -426,7 +426,7 @@ when calling one of the batching functions (such as `shuffle_batch` or
 
 SparseTensors don't play well with queues. If you use SparseTensors you have
 to decode the string records using
-@{tf.parse_example} **after**
+`tf.parse_example` **after**
 batching (instead of using `tf.parse_single_example` before batching).
 
 ## Preloaded data
@@ -475,11 +475,11 @@ update it when training.  Setting `collections=[]` keeps the variable out of the
 `GraphKeys.GLOBAL_VARIABLES` collection used for saving and restoring checkpoints.
 
 Either way,
-@{tf.train.slice_input_producer}
+`tf.train.slice_input_producer`
 can be used to produce a slice at a time.  This shuffles the examples across an
 entire epoch, so further shuffling when batching is undesirable.  So instead of
 using the `shuffle_batch` functions, we use the plain
-@{tf.train.batch} function.  To use
+`tf.train.batch` function.  To use
 multiple preprocessing threads, set the `num_threads` parameter to a number
 bigger than 1.
 
@@ -500,23 +500,23 @@ sessions, maybe in separate processes:
 * The evaluation process restores the checkpoint files into an inference
   model that reads validation input data.
 
-This is what is done @{tf.estimator$estimators} and manually in
-@{$deep_cnn#save-and-restore-checkpoints$the example CIFAR-10 model}.
+This is what is done `tf.estimator` and manually in
+[the example CIFAR-10 model](../../tutorials/images/deep_cnn.md#save-and-restore-checkpoints).
 This has a couple of benefits:
 
 * The eval is performed on a single snapshot of the trained variables.
 * You can perform the eval even after training has completed and exited.
 
 You can have the train and eval in the same graph in the same process, and share
-their trained variables or layers. See @{$variables$the shared variables tutorial}.
+their trained variables or layers. See [the shared variables tutorial](../../guide/variables.md).
 
 To support the single-graph approach
-@{$programmers_guide/datasets$`tf.data`} also supplies
-@{$programmers_guide/datasets#creating_an_iterator$advanced iterator types} that
+[`tf.data`](../../guide/datasets.md) also supplies
+[advanced iterator types](../../guide/datasets.md#creating_an_iterator) that
 that allow the user to change the input pipeline without rebuilding the graph or
 session.
 
 Note: Regardless of the implementation, many
-operations (like @{tf.layers.batch_normalization}, and @{tf.layers.dropout})
+operations (like `tf.layers.batch_normalization`, and `tf.layers.dropout`)
 need to know if they are in training or evaluation mode, and you must be
 careful to set this appropriately if you change the data source.
diff --git a/api_guides/python/regression_examples.md b/api_guides/python/regression_examples.md
index 7de2be0..3394057 100644
--- a/api_guides/python/regression_examples.md
+++ b/api_guides/python/regression_examples.md
@@ -8,25 +8,25 @@ to implement regression in Estimators:
 
   <tr>
     <td><a href="https://www.tensorflow.org/code/tensorflow/examples/get_started/regression/linear_regression.py">linear_regression.py</a></td>
-    <td>Use the @{tf.estimator.LinearRegressor} Estimator to train a
+    <td>Use the `tf.estimator.LinearRegressor` Estimator to train a
         regression model on numeric data.</td>
   </tr>
 
   <tr>
     <td><a href="https://www.tensorflow.org/code/tensorflow/examples/get_started/regression/linear_regression_categorical.py">linear_regression_categorical.py</a></td>
-    <td>Use the @{tf.estimator.LinearRegressor} Estimator to train a
+    <td>Use the `tf.estimator.LinearRegressor` Estimator to train a
         regression model on categorical data.</td>
   </tr>
 
   <tr>
     <td><a href="https://www.tensorflow.org/code/tensorflow/examples/get_started/regression/dnn_regression.py">dnn_regression.py</a></td>
-    <td>Use the @{tf.estimator.DNNRegressor} Estimator to train a
+    <td>Use the `tf.estimator.DNNRegressor` Estimator to train a
         regression model on discrete data with a deep neural network.</td>
   </tr>
 
   <tr>
     <td><a href="https://www.tensorflow.org/code/tensorflow/examples/get_started/regression/custom_regression.py">custom_regression.py</a></td>
-    <td>Use @{tf.estimator.Estimator} to train a customized dnn
+    <td>Use `tf.estimator.Estimator` to train a customized dnn
         regression model.</td>
   </tr>
 
@@ -66,7 +66,7 @@ watch the following video:
 <a name="running"></a>
 ## Running the examples
 
-You must @{$install$install TensorFlow} prior to running these examples.
+You must [install TensorFlow](../../install/) prior to running these examples.
 Depending on the way you've installed TensorFlow, you might also
 need to activate your TensorFlow environment.  Then, do the following:
 
@@ -219,7 +219,7 @@ The `custom_regression.py` example also trains a model that predicts the price
 of a car based on mixed real-valued and categorical input features, described by
 feature_columns. Unlike `linear_regression_categorical.py`, and
 `dnn_regression.py` this example does not use a pre-made estimator, but defines
-a custom model using the base @{tf.estimator.Estimator$`Estimator`} class. The
+a custom model using the base `tf.estimator.Estimator` class. The
 custom model is quite similar to the model defined by `dnn_regression.py`.
 
 The custom model is defined by the `model_fn` argument to the constructor. The
@@ -227,6 +227,6 @@ customization is made more reusable through `params` dictionary, which is later
 passed through to the `model_fn` when the `model_fn` is called.
 
 The `model_fn` returns an
-@{tf.estimator.EstimatorSpec$`EstimatorSpec`} which is a simple structure
+`tf.estimator.EstimatorSpec` which is a simple structure
 indicating to the `Estimator` which operations should be run to accomplish
 various tasks.
diff --git a/api_guides/python/session_ops.md b/api_guides/python/session_ops.md
index 5176e35..5f41bcf 100644
--- a/api_guides/python/session_ops.md
+++ b/api_guides/python/session_ops.md
@@ -1,7 +1,7 @@
 # Tensor Handle Operations
 
 Note: Functions taking `Tensor` arguments can also take anything accepted by
-@{tf.convert_to_tensor}.
+`tf.convert_to_tensor`.
 
 [TOC]
 
@@ -10,6 +10,6 @@ Note: Functions taking `Tensor` arguments can also take anything accepted by
 TensorFlow provides several operators that allows the user to keep tensors
 "in-place" across run calls.
 
-*   @{tf.get_session_handle}
-*   @{tf.get_session_tensor}
-*   @{tf.delete_session_tensor}
+*   `tf.get_session_handle`
+*   `tf.get_session_tensor`
+*   `tf.delete_session_tensor`
diff --git a/api_guides/python/sparse_ops.md b/api_guides/python/sparse_ops.md
index 19d5fab..b360055 100644
--- a/api_guides/python/sparse_ops.md
+++ b/api_guides/python/sparse_ops.md
@@ -1,7 +1,7 @@
 # Sparse Tensors
 
 Note: Functions taking `Tensor` arguments can also take anything accepted by
-@{tf.convert_to_tensor}.
+`tf.convert_to_tensor`.
 
 [TOC]
 
@@ -12,34 +12,34 @@ in multiple dimensions. Contrast this representation with `IndexedSlices`,
 which is efficient for representing tensors that are sparse in their first
 dimension, and dense along all other dimensions.
 
-*   @{tf.SparseTensor}
-*   @{tf.SparseTensorValue}
+*   `tf.SparseTensor`
+*   `tf.SparseTensorValue`
 
 ## Conversion
 
-*   @{tf.sparse_to_dense}
-*   @{tf.sparse_tensor_to_dense}
-*   @{tf.sparse_to_indicator}
-*   @{tf.sparse_merge}
+*   `tf.sparse_to_dense`
+*   `tf.sparse_tensor_to_dense`
+*   `tf.sparse_to_indicator`
+*   `tf.sparse_merge`
 
 ## Manipulation
 
-*   @{tf.sparse_concat}
-*   @{tf.sparse_reorder}
-*   @{tf.sparse_reshape}
-*   @{tf.sparse_split}
-*   @{tf.sparse_retain}
-*   @{tf.sparse_reset_shape}
-*   @{tf.sparse_fill_empty_rows}
-*   @{tf.sparse_transpose}
+*   `tf.sparse_concat`
+*   `tf.sparse_reorder`
+*   `tf.sparse_reshape`
+*   `tf.sparse_split`
+*   `tf.sparse_retain`
+*   `tf.sparse_reset_shape`
+*   `tf.sparse_fill_empty_rows`
+*   `tf.sparse_transpose`
 
 ## Reduction
-*   @{tf.sparse_reduce_sum}
-*   @{tf.sparse_reduce_sum_sparse}
+*   `tf.sparse_reduce_sum`
+*   `tf.sparse_reduce_sum_sparse`
 
 ## Math Operations
-*   @{tf.sparse_add}
-*   @{tf.sparse_softmax}
-*   @{tf.sparse_tensor_dense_matmul}
-*   @{tf.sparse_maximum}
-*   @{tf.sparse_minimum}
+*   `tf.sparse_add`
+*   `tf.sparse_softmax`
+*   `tf.sparse_tensor_dense_matmul`
+*   `tf.sparse_maximum`
+*   `tf.sparse_minimum`
diff --git a/api_guides/python/spectral_ops.md b/api_guides/python/spectral_ops.md
index 022c471..f6d109a 100644
--- a/api_guides/python/spectral_ops.md
+++ b/api_guides/python/spectral_ops.md
@@ -2,24 +2,25 @@
 
 [TOC]
 
-The @{tf.spectral} module supports several spectral decomposition operations
+The `tf.spectral` module supports several spectral decomposition operations
 that you can use to transform Tensors of real and complex signals.
 
 ## Discrete Fourier Transforms
 
-*   @{tf.spectral.fft}
-*   @{tf.spectral.ifft}
-*   @{tf.spectral.fft2d}
-*   @{tf.spectral.ifft2d}
-*   @{tf.spectral.fft3d}
-*   @{tf.spectral.ifft3d}
-*   @{tf.spectral.rfft}
-*   @{tf.spectral.irfft}
-*   @{tf.spectral.rfft2d}
-*   @{tf.spectral.irfft2d}
-*   @{tf.spectral.rfft3d}
-*   @{tf.spectral.irfft3d}
+*   `tf.spectral.fft`
+*   `tf.spectral.ifft`
+*   `tf.spectral.fft2d`
+*   `tf.spectral.ifft2d`
+*   `tf.spectral.fft3d`
+*   `tf.spectral.ifft3d`
+*   `tf.spectral.rfft`
+*   `tf.spectral.irfft`
+*   `tf.spectral.rfft2d`
+*   `tf.spectral.irfft2d`
+*   `tf.spectral.rfft3d`
+*   `tf.spectral.irfft3d`
 
 ## Discrete Cosine Transforms
 
-*   @{tf.spectral.dct}
+*   `tf.spectral.dct`
+*   `tf.spectral.idct`
diff --git a/api_guides/python/state_ops.md b/api_guides/python/state_ops.md
index ec2d877..fc55ea1 100644
--- a/api_guides/python/state_ops.md
+++ b/api_guides/python/state_ops.md
@@ -1,68 +1,68 @@
 # Variables
 
 Note: Functions taking `Tensor` arguments can also take anything accepted by
-@{tf.convert_to_tensor}.
+`tf.convert_to_tensor`.
 
 [TOC]
 
 ## Variables
 
-*   @{tf.Variable}
+*   `tf.Variable`
 
 ## Variable helper functions
 
 TensorFlow provides a set of functions to help manage the set of variables
 collected in the graph.
 
-*   @{tf.global_variables}
-*   @{tf.local_variables}
-*   @{tf.model_variables}
-*   @{tf.trainable_variables}
-*   @{tf.moving_average_variables}
-*   @{tf.global_variables_initializer}
-*   @{tf.local_variables_initializer}
-*   @{tf.variables_initializer}
-*   @{tf.is_variable_initialized}
-*   @{tf.report_uninitialized_variables}
-*   @{tf.assert_variables_initialized}
-*   @{tf.assign}
-*   @{tf.assign_add}
-*   @{tf.assign_sub}
+*   `tf.global_variables`
+*   `tf.local_variables`
+*   `tf.model_variables`
+*   `tf.trainable_variables`
+*   `tf.moving_average_variables`
+*   `tf.global_variables_initializer`
+*   `tf.local_variables_initializer`
+*   `tf.variables_initializer`
+*   `tf.is_variable_initialized`
+*   `tf.report_uninitialized_variables`
+*   `tf.assert_variables_initialized`
+*   `tf.assign`
+*   `tf.assign_add`
+*   `tf.assign_sub`
 
 ## Saving and Restoring Variables
 
-*   @{tf.train.Saver}
-*   @{tf.train.latest_checkpoint}
-*   @{tf.train.get_checkpoint_state}
-*   @{tf.train.update_checkpoint_state}
+*   `tf.train.Saver`
+*   `tf.train.latest_checkpoint`
+*   `tf.train.get_checkpoint_state`
+*   `tf.train.update_checkpoint_state`
 
 ## Sharing Variables
 
 TensorFlow provides several classes and operations that you can use to
 create variables contingent on certain conditions.
 
-*   @{tf.get_variable}
-*   @{tf.get_local_variable}
-*   @{tf.VariableScope}
-*   @{tf.variable_scope}
-*   @{tf.variable_op_scope}
-*   @{tf.get_variable_scope}
-*   @{tf.make_template}
-*   @{tf.no_regularizer}
-*   @{tf.constant_initializer}
-*   @{tf.random_normal_initializer}
-*   @{tf.truncated_normal_initializer}
-*   @{tf.random_uniform_initializer}
-*   @{tf.uniform_unit_scaling_initializer}
-*   @{tf.zeros_initializer}
-*   @{tf.ones_initializer}
-*   @{tf.orthogonal_initializer}
+*   `tf.get_variable`
+*   `tf.get_local_variable`
+*   `tf.VariableScope`
+*   `tf.variable_scope`
+*   `tf.variable_op_scope`
+*   `tf.get_variable_scope`
+*   `tf.make_template`
+*   `tf.no_regularizer`
+*   `tf.constant_initializer`
+*   `tf.random_normal_initializer`
+*   `tf.truncated_normal_initializer`
+*   `tf.random_uniform_initializer`
+*   `tf.uniform_unit_scaling_initializer`
+*   `tf.zeros_initializer`
+*   `tf.ones_initializer`
+*   `tf.orthogonal_initializer`
 
 ## Variable Partitioners for Sharding
 
-*   @{tf.fixed_size_partitioner}
-*   @{tf.variable_axis_size_partitioner}
-*   @{tf.min_max_variable_partitioner}
+*   `tf.fixed_size_partitioner`
+*   `tf.variable_axis_size_partitioner`
+*   `tf.min_max_variable_partitioner`
 
 ## Sparse Variable Updates
 
@@ -73,38 +73,38 @@ only a small subset of embedding vectors change in any given step.
 
 Since a sparse update of a large tensor may be generated automatically during
 gradient computation (as in the gradient of
-@{tf.gather}),
-an @{tf.IndexedSlices} class is provided that encapsulates a set
+`tf.gather`),
+an `tf.IndexedSlices` class is provided that encapsulates a set
 of sparse indices and values.  `IndexedSlices` objects are detected and handled
 automatically by the optimizers in most cases.
 
-*   @{tf.scatter_update}
-*   @{tf.scatter_add}
-*   @{tf.scatter_sub}
-*   @{tf.scatter_mul}
-*   @{tf.scatter_div}
-*   @{tf.scatter_min}
-*   @{tf.scatter_max}
-*   @{tf.scatter_nd_update}
-*   @{tf.scatter_nd_add}
-*   @{tf.scatter_nd_sub}
-*   @{tf.sparse_mask}
-*   @{tf.IndexedSlices}
+*   `tf.scatter_update`
+*   `tf.scatter_add`
+*   `tf.scatter_sub`
+*   `tf.scatter_mul`
+*   `tf.scatter_div`
+*   `tf.scatter_min`
+*   `tf.scatter_max`
+*   `tf.scatter_nd_update`
+*   `tf.scatter_nd_add`
+*   `tf.scatter_nd_sub`
+*   `tf.sparse_mask`
+*   `tf.IndexedSlices`
 
 ### Read-only Lookup Tables
 
-*   @{tf.initialize_all_tables}
-*   @{tf.tables_initializer}
+*   `tf.initialize_all_tables`
+*   `tf.tables_initializer`
 
 
 ## Exporting and Importing Meta Graphs
 
-*   @{tf.train.export_meta_graph}
-*   @{tf.train.import_meta_graph}
+*   `tf.train.export_meta_graph`
+*   `tf.train.import_meta_graph`
 
 # Deprecated functions (removed after 2017-03-02). Please don't use them.
 
-*   @{tf.all_variables}
-*   @{tf.initialize_all_variables}
-*   @{tf.initialize_local_variables}
-*   @{tf.initialize_variables}
+*   `tf.all_variables`
+*   `tf.initialize_all_variables`
+*   `tf.initialize_local_variables`
+*   `tf.initialize_variables`
diff --git a/api_guides/python/string_ops.md b/api_guides/python/string_ops.md
index e9be4f1..24a3aad 100644
--- a/api_guides/python/string_ops.md
+++ b/api_guides/python/string_ops.md
@@ -1,7 +1,7 @@
 # Strings
 
 Note: Functions taking `Tensor` arguments can also take anything accepted by
-@{tf.convert_to_tensor}.
+`tf.convert_to_tensor`.
 
 [TOC]
 
@@ -10,30 +10,30 @@ Note: Functions taking `Tensor` arguments can also take anything accepted by
 String hashing ops take a string input tensor and map each element to an
 integer.
 
-*   @{tf.string_to_hash_bucket_fast}
-*   @{tf.string_to_hash_bucket_strong}
-*   @{tf.string_to_hash_bucket}
+*   `tf.string_to_hash_bucket_fast`
+*   `tf.string_to_hash_bucket_strong`
+*   `tf.string_to_hash_bucket`
 
 ## Joining
 
 String joining ops concatenate elements of input string tensors to produce a new
 string tensor.
 
-*   @{tf.reduce_join}
-*   @{tf.string_join}
+*   `tf.reduce_join`
+*   `tf.string_join`
 
 ## Splitting
 
-*   @{tf.string_split}
-*   @{tf.substr}
+*   `tf.string_split`
+*   `tf.substr`
 
 ## Conversion
 
-*   @{tf.as_string}
-*   @{tf.string_to_number}
+*   `tf.as_string`
+*   `tf.string_to_number`
 
-*   @{tf.decode_raw}
-*   @{tf.decode_csv}
+*   `tf.decode_raw`
+*   `tf.decode_csv`
 
-*   @{tf.encode_base64}
-*   @{tf.decode_base64}
+*   `tf.encode_base64`
+*   `tf.decode_base64`
diff --git a/api_guides/python/summary.md b/api_guides/python/summary.md
index eda119a..fc45e7b 100644
--- a/api_guides/python/summary.md
+++ b/api_guides/python/summary.md
@@ -2,22 +2,22 @@
 [TOC]
 
 Summaries provide a way to export condensed information about a model, which is
-then accessible in tools such as @{$summaries_and_tensorboard$TensorBoard}.
+then accessible in tools such as [TensorBoard](../../guide/summaries_and_tensorboard.md).
 
 ## Generation of Summaries
 
 ### Class for writing Summaries
-*   @{tf.summary.FileWriter}
-*   @{tf.summary.FileWriterCache}
+*   `tf.summary.FileWriter`
+*   `tf.summary.FileWriterCache`
 
 ### Summary Ops
-*   @{tf.summary.tensor_summary}
-*   @{tf.summary.scalar}
-*   @{tf.summary.histogram}
-*   @{tf.summary.audio}
-*   @{tf.summary.image}
-*   @{tf.summary.merge}
-*   @{tf.summary.merge_all}
+*   `tf.summary.tensor_summary`
+*   `tf.summary.scalar`
+*   `tf.summary.histogram`
+*   `tf.summary.audio`
+*   `tf.summary.image`
+*   `tf.summary.merge`
+*   `tf.summary.merge_all`
 
 ## Utilities
-*   @{tf.summary.get_summary_description}
+*   `tf.summary.get_summary_description`
diff --git a/api_guides/python/test.md b/api_guides/python/test.md
index 5dc8812..b6e0a33 100644
--- a/api_guides/python/test.md
+++ b/api_guides/python/test.md
@@ -23,25 +23,25 @@ which adds methods relevant to TensorFlow tests.  Here is an example:
 ```
 
 `tf.test.TestCase` inherits from `unittest.TestCase` but adds a few additional
-methods.  See @{tf.test.TestCase} for details.
+methods.  See `tf.test.TestCase` for details.
 
-*   @{tf.test.main}
-*   @{tf.test.TestCase}
-*   @{tf.test.test_src_dir_path}
+*   `tf.test.main`
+*   `tf.test.TestCase`
+*   `tf.test.test_src_dir_path`
 
 ## Utilities
 
 Note: `tf.test.mock` is an alias to the python `mock` or `unittest.mock`
 depending on the python version.
 
-*   @{tf.test.assert_equal_graph_def}
-*   @{tf.test.get_temp_dir}
-*   @{tf.test.is_built_with_cuda}
-*   @{tf.test.is_gpu_available}
-*   @{tf.test.gpu_device_name}
+*   `tf.test.assert_equal_graph_def`
+*   `tf.test.get_temp_dir`
+*   `tf.test.is_built_with_cuda`
+*   `tf.test.is_gpu_available`
+*   `tf.test.gpu_device_name`
 
 ## Gradient checking
 
-@{tf.test.compute_gradient} and @{tf.test.compute_gradient_error} perform
+`tf.test.compute_gradient` and `tf.test.compute_gradient_error` perform
 numerical differentiation of graphs for comparison against registered analytic
 gradients.
diff --git a/api_guides/python/tfdbg.md b/api_guides/python/tfdbg.md
index 2212a2d..9778cdc 100644
--- a/api_guides/python/tfdbg.md
+++ b/api_guides/python/tfdbg.md
@@ -8,9 +8,9 @@ Public Python API of TensorFlow Debugger (tfdbg).
 These functions help you modify `RunOptions` to specify which `Tensor`s are to
 be watched when the TensorFlow graph is executed at runtime.
 
-*   @{tfdbg.add_debug_tensor_watch}
-*   @{tfdbg.watch_graph}
-*   @{tfdbg.watch_graph_with_blacklists}
+*   `tfdbg.add_debug_tensor_watch`
+*   `tfdbg.watch_graph`
+*   `tfdbg.watch_graph_with_blacklists`
 
 
 ## Classes for debug-dump data and directories
@@ -18,13 +18,13 @@ be watched when the TensorFlow graph is executed at runtime.
 These classes allow you to load and inspect tensor values dumped from
 TensorFlow graphs during runtime.
 
-*   @{tfdbg.DebugTensorDatum}
-*   @{tfdbg.DebugDumpDir}
+*   `tfdbg.DebugTensorDatum`
+*   `tfdbg.DebugDumpDir`
 
 
 ## Functions for loading debug-dump data
 
-*   @{tfdbg.load_tensor_from_event_file}
+*   `tfdbg.load_tensor_from_event_file`
 
 
 ## Tensor-value predicates
@@ -32,7 +32,7 @@ TensorFlow graphs during runtime.
 Built-in tensor-filter predicates to support conditional breakpoint between
 runs. See `DebugDumpDir.find()` for more details.
 
-*   @{tfdbg.has_inf_or_nan}
+*   `tfdbg.has_inf_or_nan`
 
 
 ## Session wrapper class and `SessionRunHook` implementations
@@ -44,7 +44,7 @@ These classes allow you to
 * generate `SessionRunHook` objects to debug `tf.contrib.learn` models (see
   `DumpingDebugHook` and `LocalCLIDebugHook`).
 
-*   @{tfdbg.DumpingDebugHook}
-*   @{tfdbg.DumpingDebugWrapperSession}
-*   @{tfdbg.LocalCLIDebugHook}
-*   @{tfdbg.LocalCLIDebugWrapperSession}
+*   `tfdbg.DumpingDebugHook`
+*   `tfdbg.DumpingDebugWrapperSession`
+*   `tfdbg.LocalCLIDebugHook`
+*   `tfdbg.LocalCLIDebugWrapperSession`
diff --git a/api_guides/python/threading_and_queues.md b/api_guides/python/threading_and_queues.md
index 8ad4c4c..e00f17f 100644
--- a/api_guides/python/threading_and_queues.md
+++ b/api_guides/python/threading_and_queues.md
@@ -3,7 +3,7 @@
 Note: In versions of TensorFlow before 1.2, we recommended using multi-threaded,
 queue-based input pipelines for performance. Beginning with TensorFlow 1.4,
 however, we recommend using the `tf.data` module instead. (See
-@{$datasets$Datasets} for details. In TensorFlow 1.2 and 1.3, the module was
+[Datasets](../../guide/datasets.md) for details. In TensorFlow 1.2 and 1.3, the module was
 called `tf.contrib.data`.) The `tf.data` module offers an easier-to-use
 interface for constructing efficient input pipelines. Furthermore, we've stopped
 developing the old multi-threaded, queue-based input pipelines.  We've retained
@@ -25,7 +25,7 @@ longer holds, the queue will unblock the step and allow execution to proceed.
 TensorFlow implements several classes of queue. The principal difference between
 these classes is the order that items are removed from the queue.  To get a feel
 for queues, let's consider a simple example. We will create a "first in, first
-out" queue (@{tf.FIFOQueue}) and fill it with zeros.  Then we'll construct a
+out" queue (`tf.FIFOQueue`) and fill it with zeros.  Then we'll construct a
 graph that takes an item off the queue, adds one to that item, and puts it back
 on the end of the queue. Slowly, the numbers on the queue increase.
 
@@ -47,8 +47,8 @@ Now that you have a bit of a feel for queues, let's dive into the details...
 
 ## Queue usage overview
 
-Queues, such as @{tf.FIFOQueue}
-and @{tf.RandomShuffleQueue},
+Queues, such as `tf.FIFOQueue`
+and `tf.RandomShuffleQueue`,
 are important TensorFlow objects that aid in computing tensors asynchronously
 in a graph.
 
@@ -59,11 +59,11 @@ prepare inputs for training a model as follows:
 * A training thread executes a training op that dequeues mini-batches from the
   queue
 
-We recommend using the @{tf.data.Dataset.shuffle$`shuffle`}
-and @{tf.data.Dataset.batch$`batch`} methods of a
-@{tf.data.Dataset$`Dataset`} to accomplish this. However, if you'd prefer
+We recommend using the `tf.data.Dataset.shuffle`
+and `tf.data.Dataset.batch` methods of a
+`tf.data.Dataset` to accomplish this. However, if you'd prefer
 to use a queue-based version instead, you can find a full implementation in the
-@{tf.train.shuffle_batch} function.
+`tf.train.shuffle_batch` function.
 
 For demonstration purposes a simplified implementation is given below.
 
@@ -93,8 +93,8 @@ def simple_shuffle_batch(source, capacity, batch_size=10):
   return queue.dequeue_many(batch_size)
 ```
 
-Once started by @{tf.train.start_queue_runners}, or indirectly through
-@{tf.train.MonitoredSession}, the `QueueRunner` will launch the
+Once started by `tf.train.start_queue_runners`, or indirectly through
+`tf.train.MonitoredSession`, the `QueueRunner` will launch the
 threads in the background to fill the queue. Meanwhile the main thread will
 execute the `dequeue_many` op to pull data from it. Note how these ops do not
 depend on each other, except indirectly through the internal state of the queue.
@@ -126,7 +126,7 @@ with tf.train.MonitoredSession() as sess:
 ```
 
 For most use cases, the automatic thread startup and management provided
-by @{tf.train.MonitoredSession} is sufficient. In the rare case that it is not,
+by `tf.train.MonitoredSession` is sufficient. In the rare case that it is not,
 TensorFlow provides tools for manually managing your threads and queues.
 
 ## Manual Thread Management
@@ -139,8 +139,8 @@ threads must be able to stop together, exceptions must be caught and
 reported, and queues must be properly closed when stopping.
 
 TensorFlow provides two classes to help:
-@{tf.train.Coordinator} and
-@{tf.train.QueueRunner}. These two classes
+`tf.train.Coordinator` and
+`tf.train.QueueRunner`. These two classes
 are designed to be used together. The `Coordinator` class helps multiple threads
 stop together and report exceptions to a program that waits for them to stop.
 The `QueueRunner` class is used to create a number of threads cooperating to
@@ -148,14 +148,14 @@ enqueue tensors in the same queue.
 
 ### Coordinator
 
-The @{tf.train.Coordinator} class manages background threads in a TensorFlow
+The `tf.train.Coordinator` class manages background threads in a TensorFlow
 program and helps multiple threads stop together.
 
 Its key methods are:
 
-* @{tf.train.Coordinator.should_stop}: returns `True` if the threads should stop.
-* @{tf.train.Coordinator.request_stop}: requests that threads should stop.
-* @{tf.train.Coordinator.join}: waits until the specified threads have stopped.
+* `tf.train.Coordinator.should_stop`: returns `True` if the threads should stop.
+* `tf.train.Coordinator.request_stop`: requests that threads should stop.
+* `tf.train.Coordinator.join`: waits until the specified threads have stopped.
 
 You first create a `Coordinator` object, and then create a number of threads
 that use the coordinator.  The threads typically run loops that stop when
@@ -191,11 +191,11 @@ coord.join(threads)
 
 Obviously, the coordinator can manage threads doing very different things.
 They don't have to be all the same as in the example above.  The coordinator
-also has support to capture and report exceptions.  See the @{tf.train.Coordinator} documentation for more details.
+also has support to capture and report exceptions.  See the `tf.train.Coordinator` documentation for more details.
 
 ### QueueRunner
 
-The @{tf.train.QueueRunner} class creates a number of threads that repeatedly
+The `tf.train.QueueRunner` class creates a number of threads that repeatedly
 run an enqueue op.  These threads can use a coordinator to stop together.  In
 addition, a queue runner will run a *closer operation* that closes the queue if
 an exception is reported to the coordinator.
diff --git a/api_guides/python/train.md b/api_guides/python/train.md
index 80fe978..4b4c6a4 100644
--- a/api_guides/python/train.md
+++ b/api_guides/python/train.md
@@ -1,7 +1,7 @@
 # Training
 [TOC]
 
-@{tf.train} provides a set of classes and functions that help train models.
+`tf.train` provides a set of classes and functions that help train models.
 
 ## Optimizers
 
@@ -12,19 +12,19 @@ optimization algorithms such as GradientDescent and Adagrad.
 You never instantiate the Optimizer class itself, but instead instantiate one
 of the subclasses.
 
-*   @{tf.train.Optimizer}
-*   @{tf.train.GradientDescentOptimizer}
-*   @{tf.train.AdadeltaOptimizer}
-*   @{tf.train.AdagradOptimizer}
-*   @{tf.train.AdagradDAOptimizer}
-*   @{tf.train.MomentumOptimizer}
-*   @{tf.train.AdamOptimizer}
-*   @{tf.train.FtrlOptimizer}
-*   @{tf.train.ProximalGradientDescentOptimizer}
-*   @{tf.train.ProximalAdagradOptimizer}
-*   @{tf.train.RMSPropOptimizer}
+*   `tf.train.Optimizer`
+*   `tf.train.GradientDescentOptimizer`
+*   `tf.train.AdadeltaOptimizer`
+*   `tf.train.AdagradOptimizer`
+*   `tf.train.AdagradDAOptimizer`
+*   `tf.train.MomentumOptimizer`
+*   `tf.train.AdamOptimizer`
+*   `tf.train.FtrlOptimizer`
+*   `tf.train.ProximalGradientDescentOptimizer`
+*   `tf.train.ProximalAdagradOptimizer`
+*   `tf.train.RMSPropOptimizer`
 
-See @{tf.contrib.opt} for more optimizers.
+See `tf.contrib.opt` for more optimizers.
 
 ## Gradient Computation
 
@@ -34,10 +34,10 @@ optimizer classes automatically compute derivatives on your graph, but
 creators of new Optimizers or expert users can call the lower-level
 functions below.
 
-*   @{tf.gradients}
-*   @{tf.AggregationMethod}
-*   @{tf.stop_gradient}
-*   @{tf.hessians}
+*   `tf.gradients`
+*   `tf.AggregationMethod`
+*   `tf.stop_gradient`
+*   `tf.hessians`
 
 
 ## Gradient Clipping
@@ -47,21 +47,22 @@ functions to your graph. You can use these functions to perform general data
 clipping, but they're particularly useful for handling exploding or vanishing
 gradients.
 
-*   @{tf.clip_by_value}
-*   @{tf.clip_by_norm}
-*   @{tf.clip_by_average_norm}
-*   @{tf.clip_by_global_norm}
-*   @{tf.global_norm}
+*   `tf.clip_by_value`
+*   `tf.clip_by_norm`
+*   `tf.clip_by_average_norm`
+*   `tf.clip_by_global_norm`
+*   `tf.global_norm`
 
 ## Decaying the learning rate
-*   @{tf.train.exponential_decay}
-*   @{tf.train.inverse_time_decay}
-*   @{tf.train.natural_exp_decay}
-*   @{tf.train.piecewise_constant}
-*   @{tf.train.polynomial_decay}
-*   @{tf.train.cosine_decay}
-*   @{tf.train.linear_cosine_decay}
-*   @{tf.train.noisy_linear_cosine_decay}
+
+*   `tf.train.exponential_decay`
+*   `tf.train.inverse_time_decay`
+*   `tf.train.natural_exp_decay`
+*   `tf.train.piecewise_constant`
+*   `tf.train.polynomial_decay`
+*   `tf.train.cosine_decay`
+*   `tf.train.linear_cosine_decay`
+*   `tf.train.noisy_linear_cosine_decay`
 
 ## Moving Averages
 
@@ -69,70 +70,70 @@ Some training algorithms, such as GradientDescent and Momentum often benefit
 from maintaining a moving average of variables during optimization.  Using the
 moving averages for evaluations often improve results significantly.
 
-*   @{tf.train.ExponentialMovingAverage}
+*   `tf.train.ExponentialMovingAverage`
 
 ## Coordinator and QueueRunner
 
-See @{$threading_and_queues$Threading and Queues}
+See [Threading and Queues](../../api_guides/python/threading_and_queues.md)
 for how to use threads and queues.  For documentation on the Queue API,
-see @{$python/io_ops#queues$Queues}.
+see [Queues](../../api_guides/python/io_ops.md#queues).
 
 
-*   @{tf.train.Coordinator}
-*   @{tf.train.QueueRunner}
-*   @{tf.train.LooperThread}
-*   @{tf.train.add_queue_runner}
-*   @{tf.train.start_queue_runners}
+*   `tf.train.Coordinator`
+*   `tf.train.QueueRunner`
+*   `tf.train.LooperThread`
+*   `tf.train.add_queue_runner`
+*   `tf.train.start_queue_runners`
 
 ## Distributed execution
 
-See @{$distributed$Distributed TensorFlow} for
+See [Distributed TensorFlow](../../deploy/distributed.md) for
 more information about how to configure a distributed TensorFlow program.
 
-*   @{tf.train.Server}
-*   @{tf.train.Supervisor}
-*   @{tf.train.SessionManager}
-*   @{tf.train.ClusterSpec}
-*   @{tf.train.replica_device_setter}
-*   @{tf.train.MonitoredTrainingSession}
-*   @{tf.train.MonitoredSession}
-*   @{tf.train.SingularMonitoredSession}
-*   @{tf.train.Scaffold}
-*   @{tf.train.SessionCreator}
-*   @{tf.train.ChiefSessionCreator}
-*   @{tf.train.WorkerSessionCreator}
+*   `tf.train.Server`
+*   `tf.train.Supervisor`
+*   `tf.train.SessionManager`
+*   `tf.train.ClusterSpec`
+*   `tf.train.replica_device_setter`
+*   `tf.train.MonitoredTrainingSession`
+*   `tf.train.MonitoredSession`
+*   `tf.train.SingularMonitoredSession`
+*   `tf.train.Scaffold`
+*   `tf.train.SessionCreator`
+*   `tf.train.ChiefSessionCreator`
+*   `tf.train.WorkerSessionCreator`
 
 ## Reading Summaries from Event Files
 
-See @{$summaries_and_tensorboard$Summaries and TensorBoard} for an
+See [Summaries and TensorBoard](../../guide/summaries_and_tensorboard.md) for an
 overview of summaries, event files, and visualization in TensorBoard.
 
-*   @{tf.train.summary_iterator}
+*   `tf.train.summary_iterator`
 
 ## Training Hooks
 
 Hooks are tools that run in the process of training/evaluation of the model.
 
-*   @{tf.train.SessionRunHook}
-*   @{tf.train.SessionRunArgs}
-*   @{tf.train.SessionRunContext}
-*   @{tf.train.SessionRunValues}
-*   @{tf.train.LoggingTensorHook}
-*   @{tf.train.StopAtStepHook}
-*   @{tf.train.CheckpointSaverHook}
-*   @{tf.train.NewCheckpointReader}
-*   @{tf.train.StepCounterHook}
-*   @{tf.train.NanLossDuringTrainingError}
-*   @{tf.train.NanTensorHook}
-*   @{tf.train.SummarySaverHook}
-*   @{tf.train.GlobalStepWaiterHook}
-*   @{tf.train.FinalOpsHook}
-*   @{tf.train.FeedFnHook}
+*   `tf.train.SessionRunHook`
+*   `tf.train.SessionRunArgs`
+*   `tf.train.SessionRunContext`
+*   `tf.train.SessionRunValues`
+*   `tf.train.LoggingTensorHook`
+*   `tf.train.StopAtStepHook`
+*   `tf.train.CheckpointSaverHook`
+*   `tf.train.NewCheckpointReader`
+*   `tf.train.StepCounterHook`
+*   `tf.train.NanLossDuringTrainingError`
+*   `tf.train.NanTensorHook`
+*   `tf.train.SummarySaverHook`
+*   `tf.train.GlobalStepWaiterHook`
+*   `tf.train.FinalOpsHook`
+*   `tf.train.FeedFnHook`
 
 ## Training Utilities
 
-*   @{tf.train.global_step}
-*   @{tf.train.basic_train_loop}
-*   @{tf.train.get_global_step}
-*   @{tf.train.assert_global_step}
-*   @{tf.train.write_graph}
+*   `tf.train.global_step`
+*   `tf.train.basic_train_loop`
+*   `tf.train.get_global_step`
+*   `tf.train.assert_global_step`
+*   `tf.train.write_graph`
diff --git a/api_guides/python/upgrade.md b/api_guides/python/upgrade.md
new file mode 100644
index 0000000..e556feb
--- /dev/null
+++ b/api_guides/python/upgrade.md
@@ -0,0 +1,334 @@
+# Upgrade to TensorFlow 1.0
+
+The APIs in TensorFlow 1.0 have changed in ways that are not all backwards
+compatible.  That is, TensorFlow programs that worked on TensorFlow 0.n won't
+necessarily work on TensorFlow 1.0.  We have made this API changes to ensure an
+internally-consistent API, and do not plan to make backwards-breaking changes
+throughout the 1.N lifecycle.
+
+This guide walks you through the major changes in the API and how to
+automatically upgrade your programs for TensorFlow 1.0.  This guide not
+only steps you through the changes but also explains why we've made them.
+
+## How to upgrade
+
+If you would like to automatically  port your code to 1.0, you can try our
+`tf_upgrade.py` script. While this script handles many cases, manual changes
+are sometimes necessary.
+  Get this script from our
+[GitHub tree](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/tools/compatibility).
+
+To convert a single 0.n TensorFlow source file to 1.0, enter a
+command of the following format:
+
+<pre>
+$ <b>python tf_upgrade.py --infile</b> <i>InputFile</i> <b>--outfile</b> <i>OutputFile</i>
+</pre>
+
+For example, the following command converts a 0.n TensorFlow
+program named `test.py` to a 1.0 TensorFlow program named `test_1.0.py`:
+
+<pre>
+$ <b>python tf_upgrade.py --infile test.py --outfile test_1.0.py</b>
+</pre>
+
+The `tf_upgrade.py` script also generates a file named `report.txt`, which
+details all the changes it performed and makes additional suggestions about
+changes you might need to make manually.
+
+To upgrade a whole directory of 0.n TensorFlow programs to 1.0,
+enter a command having the following format:
+
+<pre>
+$ <b>python tf_upgrade.py --intree</b> <i>InputDir</i> <b>--outtree</b> <i>OutputDir</i>
+</pre>
+
+For example, the following command converts all the 0.n TensorFlow programs
+in the `/home/user/cool` directory, creating their 1.0 equivalents in
+the `/home/user/cool_1.0` directory:
+
+<pre>
+$ <b>python tf_upgrade.py --intree /home/user/cool --outtree /home/user/cool_1.0</b>
+</pre>
+
+### Limitations
+
+There are a few things to watch out for. Specifically:
+
+ * You must manually fix any instances of `tf.reverse()`.
+   The `tf_upgrade.py` script will warn you about `tf.reverse()` in
+   stdout and in the `report.txt` file.
+ * On reordered arguments, `tf_upgrade.py` tries to minimally reformat
+   your code, so it cannot automatically change the actual argument order.
+   Instead, `tf_upgrade.py` makes your function invocations order-independent
+   by introducing keyword arguments.
+ * Constructions like `tf.get_variable_scope().reuse_variables()`
+   will likely not work. We recommend deleting those lines and replacing
+   them with lines such as the following:
+
+   <pre class="prettyprint">
+   with tf.variable_scope(tf.get_variable_scope(), reuse=True):
+     ...
+   </pre>
+
+ * Analogously to `tf.pack` and  `tf.unpack`, we're renamed
+   `TensorArray.pack` and `TensorArray.unpack` to
+   `TensorArray.stack` and `TensorArray.unstack`. However, `TensorArray.pack`
+   and `TensorArray.unpack` cannot be detected lexically since they are
+   indirectly related to the `tf` namespace e.g.
+   `foo = tf.TensorArray(); foo.unpack()`
+
+## Upgrading your code manually
+
+Instead of running `tf_upgrade.py`, you may manually upgrade your code.
+The remainder of this document provides a comprehensive list of
+all backward incompatible changes made in TensorFlow 1.0.
+
+
+### Variables
+
+Variable functions have been made more consistent and less confusing.
+
+* `tf.VARIABLES`
+    * should be renamed to `tf.GLOBAL_VARIABLES`
+* `tf.all_variables`
+    * should be renamed to `tf.global_variables`
+* `tf.initialize_all_variables`
+    * should be renamed to `tf.global_variables_initializer`
+* `tf.initialize_local_variables`
+    * should be renamed to `tf.local_variables_initializer`
+* `tf.initialize_variables`
+    * should be renamed to `tf.variables_initializer`
+
+### Summary functions
+
+Summary functions have been consolidated under the `tf.summary` namespace.
+
+* `tf.audio_summary`
+    * should be renamed to `tf.summary.audio`
+* `tf.contrib.deprecated.histogram_summary`
+    * should be renamed to `tf.summary.histogram`
+* `tf.contrib.deprecated.scalar_summary`
+    * should be renamed to `tf.summary.scalar`
+* `tf.histogram_summary`
+    * should be renamed to `tf.summary.histogram`
+* `tf.image_summary`
+    * should be renamed to `tf.summary.image`
+* `tf.merge_all_summaries`
+    * should be renamed to `tf.summary.merge_all`
+* `tf.merge_summary`
+    * should be renamed to `tf.summary.merge`
+* `tf.scalar_summary`
+    * should be renamed to `tf.summary.scalar`
+* `tf.train.SummaryWriter`
+    * should be renamed to `tf.summary.FileWriter`
+
+### Numeric differences
+
+
+Integer division and `tf.floordiv` now uses flooring semantics. This is to
+make the results of `np.divide` and `np.mod` consistent with `tf.divide` and
+`tf.mod`, respectively. In addition we have changed the rounding algorithm
+used by `tf.round` to match NumPy.
+
+
+* `tf.div`
+
+    * The semantics of `tf.divide` division have been changed to match Python
+semantics completely. That is, `/` in Python 3     and future division mode in
+Python 2 will produce floating point numbers always, `//` will produce floored
+division.     However, even `tf.div` will produce floored integer division.
+To force C-style truncation semantics, you must use `tf.truncatediv`.
+
+    * Consider changing your code to use `tf.divide`, which follows Python semantics for promotion.
+
+* `tf.mod`
+
+    * The semantics of `tf.mod` have been changed to match Python semantics. In
+particular, flooring semantics are used for     integers. If you wish to have
+C-style truncation mod (remainders), you can use `tf.truncatemod`
+
+
+The old and new behavior of division can be summarized with this table:
+
+| Expr                | TF 0.11 (py2) | TF 0.11 (py3) | TF 1.0 (py2) | TF 1.0 (py3) |
+|---------------------|---------------|---------------|--------------|--------------|
+| tf.div(3,4)         | 0             | 0             | 0            | 0            |
+| tf.div(-3,4)        | 0             | 0             | -1           | -1           |
+| tf.mod(-3,4)        | -3            | -3            | 1            | 1            |
+| -3/4                | 0             | -0.75         | -1           | -0.75        |
+| -3/4tf.divide(-3,4) | N/A           | N/A           | -0.75        | -1           |
+
+The old and new behavior of rounding can be summarized with this table:
+
+| Input | Python | NumPy | C++ round() | TensorFlow 0.11(floor(x+.5)) | TensorFlow 1.0 |
+|-------|--------|-------|-------------|------------------------------|----------------|
+| -3.5  | -4     | -4    | -4          | -3                           | -4             |
+| -2.5  | -2     | -2    | -3          | -2                           | -2             |
+| -1.5  | -2     | -2    | -2          | -1                           | -2             |
+| -0.5  | 0      | 0     | -1          | 0                            | 0              |
+| 0.5   | 0      | 0     | 1           | 1                            | 0              |
+| 1.5   | 2      | 2     | 2           | 2                            | 2              |
+| 2.5   | 2      | 2     | 3           | 3                            | 2              |
+| 3.5   | 4      | 4     | 4           | 4                            | 4              |
+
+
+
+### NumPy matching names
+
+
+Many functions have been renamed to match NumPy. This was done to make the
+transition between NumPy and TensorFlow as easy as possible. There are still
+numerous cases where functions do not match, so this is far from a hard and
+fast rule, but we have removed several commonly noticed inconsistencies.
+
+* `tf.inv`
+    * should be renamed to `tf.reciprocal`
+    * This was done to avoid confusion with NumPy's matrix inverse `np.inv`
+* `tf.list_diff`
+    * should be renamed to `tf.setdiff1d`
+* `tf.listdiff`
+    * should be renamed to `tf.setdiff1d`
+* `tf.mul`
+    * should be renamed to `tf.multiply`
+* `tf.neg`
+    * should be renamed to `tf.negative`
+* `tf.select`
+    * should be renamed to `tf.where`
+    * `tf.where` now takes 3 arguments or 1 argument, just like `np.where`
+* `tf.sub`
+    * should be renamed to `tf.subtract`
+
+### NumPy matching arguments
+
+Arguments for certain TensorFlow 1.0 methods now match arguments in certain
+NumPy methods.  To achieve this, TensorFlow 1.0 has changed keyword arguments
+and reordered some arguments. Notably, TensorFlow 1.0 now uses `axis` rather
+than `dimension`. TensorFlow 1.0 aims to keep the tensor argument first on
+operations that modify Tensors. (see the `tf.concat` change).
+
+
+* `tf.argmax`
+    * keyword argument `dimension` should be renamed to `axis`
+* `tf.argmin`
+    * keyword argument `dimension` should be renamed to `axis`
+* `tf.concat`
+    * keyword argument `concat_dim` should be renamed to `axis`
+    * arguments have been reordered to `tf.concat(values, axis, name='concat')`.
+* `tf.count_nonzero`
+    * keyword argument `reduction_indices` should be renamed to `axis`
+* `tf.expand_dims`
+    * keyword argument `dim` should be renamed to `axis`
+* `tf.reduce_all`
+    * keyword argument `reduction_indices` should be renamed to `axis`
+* `tf.reduce_any`
+    * keyword argument `reduction_indices` should be renamed to `axis`
+* `tf.reduce_join`
+    * keyword argument `reduction_indices` should be renamed to `axis`
+* `tf.reduce_logsumexp`
+    * keyword argument `reduction_indices` should be renamed to `axis`
+* `tf.reduce_max`
+    * keyword argument `reduction_indices` should be renamed to `axis`
+* `tf.reduce_mean`
+    * keyword argument `reduction_indices` should be renamed to `axis`
+* `tf.reduce_min`
+    * keyword argument `reduction_indices` should be renamed to `axis`
+* `tf.reduce_prod`
+    * keyword argument `reduction_indices` should be renamed to `axis`
+* `tf.reduce_sum`
+    * keyword argument `reduction_indices` should be renamed to `axis`
+* `tf.reverse`
+    * `tf.reverse` used to take a 1D `bool` tensor to control which dimensions were reversed. Now we use a Tensor of axis indices.
+    * For example `tf.reverse(a, [True, False, True])` now must be `tf.reverse(a, [0, 2])`
+* `tf.reverse_sequence`
+    * keyword argument `batch_dim` should be renamed to `batch_axis`
+    * keyword argument `seq_dim` should be renamed to `seq_axis`
+* `tf.sparse_concat`
+    * keyword argument `concat_dim` should be renamed to `axis`
+* `tf.sparse_reduce_sum`
+    * keyword argument `reduction_axes` should be renamed to `axis`
+* `tf.sparse_reduce_sum_sparse`
+    * keyword argument `reduction_axes` should be renamed to `axis`
+* `tf.sparse_split`
+    * keyword argument `split_dim` should be renamed to `axis`
+    * arguments have been reordered to `tf.sparse_split(keyword_required=KeywordRequired(), sp_input=None, num_split=None, axis=None, name=None, split_dim=None)`.
+* `tf.split`
+    * keyword argument `split_dim` should be renamed to `axis`
+    * keyword argument `num_split` should be renamed to `num_or_size_splits`
+    * arguments have been reordered to `tf.split(value, num_or_size_splits, axis=0, num=None, name='split')`.
+* `tf.squeeze`
+    * keyword argument `squeeze_dims` should be renamed to `axis`
+* `tf.svd`
+    * arguments have been reordered to `tf.svd(tensor, full_matrices=False, compute_uv=True, name=None)`.
+
+### Simplified math variants
+
+Batched versions of math operations have been removed. Now the functionality is
+contained in the non-batched versions. Similarly,`tf.complex_abs` has had its
+functionality moved to `tf.abs`
+
+* `tf.batch_band_part`
+    * should be renamed to `tf.band_part`
+* `tf.batch_cholesky`
+    * should be renamed to `tf.cholesky`
+* `tf.batch_cholesky_solve`
+    * should be renamed to `tf.cholesky_solve`
+* `tf.batch_fft`
+    * should be renamed to `tf.fft`
+* `tf.batch_fft3d`
+    * should be renamed to `tf.fft3d`
+* `tf.batch_ifft`
+    * should be renamed to `tf.ifft`
+* `tf.batch_ifft2d`
+    * should be renamed to `tf.ifft2d`
+* `tf.batch_ifft3d`
+    * should be renamed to `tf.ifft3d`
+* `tf.batch_matmul`
+    * should be renamed to `tf.matmul`
+* `tf.batch_matrix_determinant`
+    * should be renamed to `tf.matrix_determinant`
+* `tf.batch_matrix_diag`
+    * should be renamed to `tf.matrix_diag`
+* `tf.batch_matrix_inverse`
+    * should be renamed to `tf.matrix_inverse`
+* `tf.batch_matrix_solve`
+    * should be renamed to `tf.matrix_solve`
+* `tf.batch_matrix_solve_ls`
+    * should be renamed to `tf.matrix_solve_ls`
+* `tf.batch_matrix_transpose`
+    * should be renamed to `tf.matrix_transpose`
+* `tf.batch_matrix_triangular_solve`
+    * should be renamed to `tf.matrix_triangular_solve`
+* `tf.batch_self_adjoint_eig`
+    * should be renamed to `tf.self_adjoint_eig`
+* `tf.batch_self_adjoint_eigvals`
+    * should be renamed to `tf.self_adjoint_eigvals`
+* `tf.batch_set_diag`
+    * should be renamed to `tf.set_diag`
+* `tf.batch_svd`
+    * should be renamed to `tf.svd`
+* `tf.complex_abs`
+    * should be renamed to `tf.abs`
+
+### Misc Changes
+
+Several other changes have been made, including the following:
+
+* `tf.image.per_image_whitening`
+    * should be renamed to `tf.image.per_image_standardization`
+* `tf.nn.sigmoid_cross_entropy_with_logits`
+    * arguments have been reordered to `tf.nn.sigmoid_cross_entropy_with_logits(_sentinel=None, labels=None, logits=None, name=None)`.
+* `tf.nn.softmax_cross_entropy_with_logits`
+    * arguments have been reordered to `tf.nn.softmax_cross_entropy_with_logits(_sentinel=None, labels=None, logits=None, dim=-1, name=None)`.
+* `tf.nn.sparse_softmax_cross_entropy_with_logits`
+    * arguments have been reordered to `tf.nn.sparse_softmax_cross_entropy_with_logits(_sentinel=None, labels=None, logits=None, name=None)`.
+* `tf.ones_initializer`
+    * should be changed to a function call i.e. `tf.ones_initializer()`
+* `tf.pack`
+    * should be renamed to `tf.stack`
+* `tf.round`
+    * The semantics of `tf.round` now match Banker's rounding.
+* `tf.unpack`
+    * should be renamed to `tf.unstack`
+* `tf.zeros_initializer`
+    * should be changed to a function call i.e. `tf.zeros_initializer()`