diff --git a/configure.py b/configure.py
index 8572fa7fdb249d1ae6f39202b871d17cd44755f8..6279c4261044e3f33519ece5f2ac19af2acb505d 100644
--- a/configure.py
+++ b/configure.py
@@ -25,10 +25,12 @@ import re
 import subprocess
 import sys
 
+# pylint: disable=g-import-not-at-top
 try:
   from shutil import which
 except ImportError:
   from distutils.spawn import find_executable as which
+# pylint: enable=g-import-not-at-top
 
 _TF_BAZELRC = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                            '.tf_configure.bazelrc')
@@ -485,7 +487,10 @@ def set_cc_opt_flags(environ_cp):
   cc_opt_flags = get_from_env_or_user_or_default(environ_cp, 'CC_OPT_FLAGS',
                                                  question, default_cc_opt_flags)
   for opt in cc_opt_flags.split():
-    write_to_bazelrc('build:opt --cxxopt=%s --copt=%s' % (opt, opt))
+    host_opt = '-march=native'  # It should be safe on the same build host.
+    write_to_bazelrc(
+        'build:opt --cxxopt=%s --copt=%s' % (opt, opt) +
+        ' --host_cxxopt=%s --host_copt=%s' % (host_opt, host_opt))
 
 
 def set_tf_cuda_clang(environ_cp):
diff --git a/tensorflow/compiler/tf2xla/functionalize_control_flow.cc b/tensorflow/compiler/tf2xla/functionalize_control_flow.cc
index 893175373f670b38b03b3492ddffb16102708160..6ef4860f35835e59be3452b57204d42c82d0816b 100644
--- a/tensorflow/compiler/tf2xla/functionalize_control_flow.cc
+++ b/tensorflow/compiler/tf2xla/functionalize_control_flow.cc
@@ -130,7 +130,9 @@ Status CopySubgraph(const Graph& graph, const Frame* frame,
         stack.push_back(src);
       }
       Node* src_copy = (*node_map)[e->src()->id()];
-      int src_output = squash_src_outputs[e->src()->id()] ? 0 : e->src_output();
+      int src_output = squash_src_outputs[e->src()->id()] && !e->IsControlEdge()
+                           ? 0
+                           : e->src_output();
       Node* dst_copy = (*node_map)[e->dst()->id()];
       output->AddEdge(src_copy, src_output, dst_copy, e->dst_input());
     }
diff --git a/tensorflow/compiler/tf2xla/kernels/gather_op.cc b/tensorflow/compiler/tf2xla/kernels/gather_op.cc
index 2c5d910d58d8e486deb1f644cbda11261b93a84e..e420f21ca33fe7de9b33f404ce04eae62d9c041e 100644
--- a/tensorflow/compiler/tf2xla/kernels/gather_op.cc
+++ b/tensorflow/compiler/tf2xla/kernels/gather_op.cc
@@ -77,18 +77,6 @@ xla::ComputationDataHandle XlaComputeGatherDynamicSlice(
                               out_shape.dim_sizes());
   }
 
-  // Degenerate case: single slice.
-  if (num_indices == 1) {
-    auto index = builder->Reshape(indices, {1});
-    auto start_index = builder->Pad(
-        index, XlaHelpers::Zero(builder, index_type),
-        xla::MakeEdgePaddingConfig(
-            {{input_shape_pre_axis.dims(), input_shape_post_axis.dims()}}));
-    auto slice =
-        builder->DynamicSlice(input, start_index, slice_shape.dim_sizes());
-    return builder->Reshape(slice, out_shape.dim_sizes());
-  }
-
   // Specify the shape of the loop-carried Tensor tuple.
   xla::PrimitiveType ptype;
   TF_CHECK_OK(DataTypeToPrimitiveType(dtype, &ptype));
diff --git a/tensorflow/compiler/xla/client/computation_builder.cc b/tensorflow/compiler/xla/client/computation_builder.cc
index 24774c4c2a385d9aabd22a550bd8be3acf409d85..763d94e94c2167f47b3f0777a31815f02791aa9e 100644
--- a/tensorflow/compiler/xla/client/computation_builder.cc
+++ b/tensorflow/compiler/xla/client/computation_builder.cc
@@ -1309,7 +1309,7 @@ Status ComputationBuilder::SetReturnValue(
 }
 
 StatusOr<bool> ComputationBuilder::IsConstant(
-    const ComputationDataHandle& operand) {
+    const ComputationDataHandle& operand, int64 num_parameters) {
   if (!first_error_.ok()) {
     return first_error_;
   }
@@ -1317,6 +1317,7 @@ StatusOr<bool> ComputationBuilder::IsConstant(
   IsConstantRequest request;
   *request.mutable_computation() = computation_.handle();
   *request.mutable_operand() = operand;
+  request.set_num_parameters(num_parameters);
   IsConstantResponse response;
 
   VLOG(2) << "making IsConstant request";
@@ -1330,7 +1331,8 @@ StatusOr<bool> ComputationBuilder::IsConstant(
 }
 
 StatusOr<std::unique_ptr<Literal>> ComputationBuilder::ComputeConstant(
-    const ComputationDataHandle& operand, const Layout* output_layout) {
+    const ComputationDataHandle& operand, const Layout* output_layout,
+    tensorflow::gtl::ArraySlice<Literal> parameters) {
   if (!first_error_.ok()) {
     return first_error_;
   }
@@ -1341,6 +1343,9 @@ StatusOr<std::unique_ptr<Literal>> ComputationBuilder::ComputeConstant(
   if (output_layout != nullptr) {
     *request.mutable_output_layout() = *output_layout;
   }
+  for (const auto& param : parameters) {
+    *request.add_parameters() = param.ToProto();
+  }
 
   ComputeConstantResponse response;
 
diff --git a/tensorflow/compiler/xla/client/computation_builder.h b/tensorflow/compiler/xla/client/computation_builder.h
index bc7ad06a3fec4aecbe11312982542c9d615b4911..8e1b4be1f3ebf8e3f530b053447f86f7a2f56fa7 100644
--- a/tensorflow/compiler/xla/client/computation_builder.h
+++ b/tensorflow/compiler/xla/client/computation_builder.h
@@ -746,11 +746,12 @@ class ComputationBuilder {
   ComputationDataHandle Recv(const Shape& shape, const ChannelHandle& handle);
 
   // Returns true if 'operand' is a compile-time constant. A compile-time
-  // constant does not depend on parameters, or on stateful operators such
-  // as `RngNormal` or `Infeed`. Unlike `ComputeConstant`, `IsConstant` tests
-  // whether a computation is a compile-time constant without evaluating the
-  // computation.
-  StatusOr<bool> IsConstant(const ComputationDataHandle& operand);
+  // constant does not depend on parameters with higher index then
+  // `num_parameters`, or on stateful operators such as `RngNormal` or `Infeed`.
+  // Unlike `ComputeConstant`, `IsConstant` tests whether a computation is a
+  // compile-time constant without evaluating the computation.
+  StatusOr<bool> IsConstant(const ComputationDataHandle& operand,
+                            int64 num_parameters = 0);
 
   // Normalizes operand across spatial and batch dimensions for each feature.
   //
@@ -795,7 +796,7 @@ class ComputationBuilder {
                                       float epsilon, int64 feature_index);
 
   // Computes the value of a constant indicated by a
-  // ComputationDataHandle.
+  // ComputationDataHandle using a non-optimized interpreter on the host.
   //
   // The operand must be from the computation currently being built -
   // i.e., returned from this builder with no intervening call to
@@ -803,8 +804,11 @@ class ComputationBuilder {
   // that may stop working at any time.
   //
   // The operand must represent a constant value, which in this case
-  // means that it must not statically depend on a parameter to the
-  // computation that is being built.
+  // means that it must not statically depend on any parameter of the
+  // computation that is being built other then the ones specified on the
+  // paramtere list. The parameters in the list will be indexed by their
+  // parameter id property so the number of parameters specified should be at
+  // least as many as the largest used parameter index.
   //
   // `IsConstant` can be used to test whether a computation is a compile-time
   // constant without evaluation it. `ComputeConstant` only succeeds for
@@ -822,7 +826,8 @@ class ComputationBuilder {
   // will be stored using that layout.
   StatusOr<std::unique_ptr<Literal>> ComputeConstant(
       const ComputationDataHandle& operand,
-      const Layout* output_layout = nullptr);
+      const Layout* output_layout = nullptr,
+      tensorflow::gtl::ArraySlice<Literal> parameters = {});
 
   // Returns a new ComputationBuilder whose resultant Computation is used only
   // by this ComputationBuilder. The sub-ComputationBuilder has the same
diff --git a/tensorflow/compiler/xla/service/buffer_assignment.cc b/tensorflow/compiler/xla/service/buffer_assignment.cc
index 8536429846f87fd5c4b073cc4b13b3f1c5eb2e5c..b422b22df9cfbefb6611fcb229ed42e67fe3a0d8 100644
--- a/tensorflow/compiler/xla/service/buffer_assignment.cc
+++ b/tensorflow/compiler/xla/service/buffer_assignment.cc
@@ -101,6 +101,11 @@ BufferAllocationProto BufferAllocation::ToProto() const {
     proto_assigned->set_offset(buffer_offset_size.second.offset);
     proto_assigned->set_size(buffer_offset_size.second.size);
   }
+  std::sort(proto.mutable_assigned()->begin(), proto.mutable_assigned()->end(),
+            [](const BufferAllocationProto::Assigned& assign1,
+               const BufferAllocationProto::Assigned& assign2) {
+              return assign1.logical_buffer_id() < assign2.logical_buffer_id();
+            });
   return proto;
 }
 
diff --git a/tensorflow/compiler/xla/service/cpu/cpu_compiler.cc b/tensorflow/compiler/xla/service/cpu/cpu_compiler.cc
index 487ea003be643a9c7d48dc2d0037ba6a0ae498dd..f46764cba0ad6ef174a89951c251613c69b4b083 100644
--- a/tensorflow/compiler/xla/service/cpu/cpu_compiler.cc
+++ b/tensorflow/compiler/xla/service/cpu/cpu_compiler.cc
@@ -322,7 +322,7 @@ Status CpuCompiler::RunHloPasses(HloModule* module, bool is_aot_compile) {
     // binary size (and most AOT applications are single-threaded).
     // TODO(29630486) Support multi-threaded AOT.
     pipeline.AddPass<ParallelTaskAssigner>(max_parallelism,
-                                           ShapeSizeBytesFunction(), module);
+                                           ShapeSizeBytesFunction());
   }
   // Copy insertion should be performed immediately before IR emission to avoid
   // inserting unnecessary copies (later pass adds an instruction which
diff --git a/tensorflow/compiler/xla/service/cpu/llvm_ir_runtime.cc b/tensorflow/compiler/xla/service/cpu/llvm_ir_runtime.cc
index b49047283119fb2f10b9f68eaa37a7bdc27f63a6..81c29e4726c7be53b433be896f558f502e43c885 100644
--- a/tensorflow/compiler/xla/service/cpu/llvm_ir_runtime.cc
+++ b/tensorflow/compiler/xla/service/cpu/llvm_ir_runtime.cc
@@ -52,7 +52,7 @@ llvm::Function* EmitVectorF32TanhIfNeeded(llvm::Module* module,
   llvm::IRBuilder<> ir_builder(vector_tanh_body);
 
   llvm::FastMathFlags fast_math_flags;
-  fast_math_flags.setUnsafeAlgebra();
+  fast_math_flags.setFast();
   ir_builder.setFastMathFlags(fast_math_flags);
 
   llvm::Value* input = &*vector_tanh_function->arg_begin();
diff --git a/tensorflow/compiler/xla/service/cpu/parallel_task_assignment.cc b/tensorflow/compiler/xla/service/cpu/parallel_task_assignment.cc
index c2213c8f2ef592c537daf9abe2ffa10b83a8fa4c..4a62a80fac0c89d8e1cf66f16f07fca0ffbaa2d3 100644
--- a/tensorflow/compiler/xla/service/cpu/parallel_task_assignment.cc
+++ b/tensorflow/compiler/xla/service/cpu/parallel_task_assignment.cc
@@ -101,11 +101,9 @@ class DefaultCostModel : public ParallelCostModel {
   const std::unique_ptr<HloCostAnalysis> cost_analysis_;
 };
 
-
 ParallelTaskAssignment::ParallelTaskAssignment(
     const int64 max_parallelism,
-    const HloCostAnalysis::ShapeSizeFunction& shape_size,
-    HloModule* module) {
+    const HloCostAnalysis::ShapeSizeFunction& shape_size, HloModule* module) {
   VLOG(1) << "ParallelTaskAssignment max_parallelism: " << max_parallelism;
   // Run cost analysis on 'module'.
   auto cost_analysis = MakeUnique<HloCostAnalysis>(shape_size);
@@ -153,7 +151,6 @@ int64 ParallelTaskAssignment::GetTargetParallelTaskCount(
 StatusOr<bool> ParallelTaskAssigner::Run(HloModule* module) {
   XLA_VLOG_LINES(2, "ParallelTaskAssigner ENTRY");
   XLA_VLOG_LINES(3, module->ToString());
-
   // Compute target parallel task counts for all instructions in 'module'.
   HloToParallelTasks hlo_to_parallel_tasks;
   ComputeTargetParallelTasks(module, &hlo_to_parallel_tasks);
@@ -230,6 +227,9 @@ bool ParallelTaskAssigner::AssignParallelTasksHelper(
 
 void ParallelTaskAssigner::ComputeTargetParallelTasks(
     HloModule* module, HloToParallelTasks* hlo_to_parallel_tasks) {
+  ParallelTaskAssignment parallel_task_assignment(max_parallelism_,
+                                                  shape_size_function_, module);
+
   // Compute parallel task counts for all instructions in 'module'.
   for (auto* computation : module->computations()) {
     if (computation->IsFusionComputation()) {
@@ -238,7 +238,7 @@ void ParallelTaskAssigner::ComputeTargetParallelTasks(
     for (auto* instruction : computation->instructions()) {
       // Query ParallelTaskAssignment for target parallel task count.
       const int64 target_parallel_task_count =
-          parallel_task_assignment_.GetTargetParallelTaskCount(instruction);
+          parallel_task_assignment.GetTargetParallelTaskCount(instruction);
       if (target_parallel_task_count > 1) {
         hlo_to_parallel_tasks->insert(
             {instruction, target_parallel_task_count});
diff --git a/tensorflow/compiler/xla/service/cpu/parallel_task_assignment.h b/tensorflow/compiler/xla/service/cpu/parallel_task_assignment.h
index e036da5784f6151eb3b01107ec7f3ab820071a60..5801ec8d270cdaed7f2f65c24987a9ea643edb02 100644
--- a/tensorflow/compiler/xla/service/cpu/parallel_task_assignment.h
+++ b/tensorflow/compiler/xla/service/cpu/parallel_task_assignment.h
@@ -37,10 +37,9 @@ class ParallelTaskAssignment {
   // 'shape_size': shape size function used by HloCostAnalysis during parallel
   //               task assignment.
   // 'module': the containing HloModule.
-  ParallelTaskAssignment(
-      const int64 max_parallelism,
-      const HloCostAnalysis::ShapeSizeFunction& shape_size,
-      HloModule* module);
+  ParallelTaskAssignment(const int64 max_parallelism,
+                         const HloCostAnalysis::ShapeSizeFunction& shape_size,
+                         HloModule* module);
   ~ParallelTaskAssignment() {}
 
   // Computes and returns the target parallel task count for 'instruction'.
@@ -63,11 +62,9 @@ class ParallelTaskAssigner : public HloPassInterface {
   // 'max_parallelism': the maximum parallel task count per instruction.
   // 'shape_size': shape size function used by HloCostAnalysis during parallel
   //               task assignment.
-  // 'module': the containing HloModule.
   ParallelTaskAssigner(const int64 max_parallelism,
-                       const HloCostAnalysis::ShapeSizeFunction& shape_size,
-                       HloModule* module)
-      : parallel_task_assignment_(max_parallelism, shape_size, module) {}
+                       const HloCostAnalysis::ShapeSizeFunction& shape_size)
+      : max_parallelism_(max_parallelism), shape_size_function_(shape_size) {}
   ~ParallelTaskAssigner() override {}
 
   tensorflow::StringPiece name() const override {
@@ -95,7 +92,8 @@ class ParallelTaskAssigner : public HloPassInterface {
   void ComputeTargetParallelTasks(HloModule* module,
                                   HloToParallelTasks* hlo_to_parallel_tasks);
 
-  ParallelTaskAssignment parallel_task_assignment_;
+  int64 max_parallelism_;
+  HloCostAnalysis::ShapeSizeFunction shape_size_function_;
 };
 
 }  // namespace cpu
diff --git a/tensorflow/compiler/xla/service/elemental_ir_emitter.cc b/tensorflow/compiler/xla/service/elemental_ir_emitter.cc
index fd4c332cba94513ec5b4cd88a842189e716f35d5..a945657712aae46093cd016d23114f26b8a2d926 100644
--- a/tensorflow/compiler/xla/service/elemental_ir_emitter.cc
+++ b/tensorflow/compiler/xla/service/elemental_ir_emitter.cc
@@ -1289,6 +1289,15 @@ llvm_ir::ElementGenerator ElementalIrEmitter::MakeElementGenerator(
         const int64 rank = ShapeUtil::Rank(input_hlo->shape());
         llvm_ir::IrArray::Index slice_start_index(rank);
         llvm_ir::IrArray::Index slice_limit_index(rank);
+        // Slice starts at update[index - slice_start_index_adjusted],
+        // where adjusted value = slice_start_index when in bounds, and
+        // adjusted value = slice_start_index - input_dim, when wrapping.
+        llvm_ir::IrArray::Index slice_start_index_adjusted(rank);
+
+        // Slice intersection gathers (ANDs) conditions on all ranks for which
+        // 'input' is set to 'update'
+        llvm::Value* slice_intersection = ir_builder_->getTrue();
+
         for (int64 i = 0; i < rank; ++i) {
           // Emit IR to read dynamic start indices from 'start_hlo'.
           llvm_ir::IrArray::Index dim_index(1, ir_builder_->getInt64(i));
@@ -1298,38 +1307,97 @@ llvm_ir::ElementGenerator ElementalIrEmitter::MakeElementGenerator(
               AsStringRef(IrName(hlo, StrCat("start_idx", i))));
           slice_start_index[i] = ir_builder_->CreateZExtOrBitCast(
               start_index_value, index[i]->getType());
-          // Emit IR to compute: slice_limit_index = start_index + update_dim
-          // NOTE: Although 'start_indices' is dynamic and could be
-          // out-of-range, we do not compute 'slice_limit_index' mod input dim
-          // size here, because subsequent array index calculations will be
-          // computed mod input dim size for safety.
+
+          llvm::Value* input_dim_size = llvm::ConstantInt::get(
+              index[i]->getType(), input_hlo->shape().dimensions(i));
           llvm::Value* update_dim_size = llvm::ConstantInt::get(
               index[i]->getType(), update_hlo->shape().dimensions(i));
+
+          // Generate code to handle wrapping semantics:
+          // slice_start_index[i] = slice_start_index[i] % input_dim_size;
+          // slice_limit_index[i] = slice_start_index[i] + update_dim_size.
+          // slice_start_index[i] is updated in place and it will now be in
+          // range. slice_limit_index[i] may be out of range, and it's being
+          // URem-ed below if so.
+          slice_start_index[i] =
+              ir_builder_->CreateURem(slice_start_index[i], input_dim_size);
           slice_limit_index[i] =
               ir_builder_->CreateAdd(slice_start_index[i], update_dim_size);
-        }
 
-        // Check if 'index' intersects start/end indices.
-        llvm::Value* slice_intersection =
-            llvm::ConstantInt::get(ir_builder_->getInt1Ty(), 1);
-
-        for (int64 i = 0; i < rank; ++i) {
-          // Check that index[i] >= slice_start_index[i].
-          slice_intersection = ir_builder_->CreateAnd(
+          // Test if slice_limit_index[i] is in bounds
+          llvm::Value* in_bounds =
+              ir_builder_->CreateICmpULE(slice_limit_index[i], input_dim_size);
+          llvm_ir::LlvmIfData if_in_bounds =
+              llvm_ir::EmitIfThenElse(in_bounds, "in_bounds", ir_builder_);
+
+          // Handle true BB (slice_limit_index[i] <= input_dim_size).
+          SetToFirstInsertPoint(if_in_bounds.true_block, ir_builder_);
+          // Check that index[i] >= slice_start_index[i] &&
+          //            index[i] < slice_limit_index[i]
+          llvm::Value* slice_intersection_in_bounds = ir_builder_->CreateAnd(
               slice_intersection,
               ir_builder_->CreateICmpSGE(index[i], slice_start_index[i]),
-              "slice_intersection");
-
-          // Check that index[i] < slice_limit_index[i].
-          slice_intersection = ir_builder_->CreateAnd(
-              slice_intersection,
+              "slice_intersection_in");
+          slice_intersection_in_bounds = ir_builder_->CreateAnd(
+              slice_intersection_in_bounds,
               ir_builder_->CreateICmpSLT(index[i], slice_limit_index[i]),
-              "slice_intersection");
+              "slice_intersection_in");
+
+          // Handle false BB (slice_limit_index[i] > input_dim_size).
+          SetToFirstInsertPoint(if_in_bounds.false_block, ir_builder_);
+          // Check that index[i] >= slice_start_index[i] ||
+          //            index[i] < slice_limit_index[i]%input_dim_size.
+          llvm::Value* index_wraps = ir_builder_->CreateICmpSLT(
+              index[i],
+              ir_builder_->CreateURem(slice_limit_index[i], input_dim_size));
+          llvm::Value* slice_intersection_or = ir_builder_->CreateOr(
+              ir_builder_->CreateICmpSGE(index[i], slice_start_index[i]),
+              index_wraps, "slice_intersection_out");
+          llvm::Value* slice_intersection_out_of_bounds =
+              ir_builder_->CreateAnd(slice_intersection, slice_intersection_or,
+                                     "slice_intersection_out");
+          // Create value for slice_start_index_adjusted[i] when out of bounds.
+          // If within out-of-bounds if.
+          llvm_ir::LlvmIfData if_start_needs_adjustment =
+              llvm_ir::EmitIfThenElse(index_wraps, "adjust_start", ir_builder_);
+          SetToFirstInsertPoint(if_start_needs_adjustment.true_block,
+                                ir_builder_);
+          llvm::Value* slice_start_index_adjusted_oob =
+              ir_builder_->CreateSub(slice_start_index[i], input_dim_size);
+          SetToFirstInsertPoint(if_start_needs_adjustment.after_block,
+                                ir_builder_);
+          llvm::PHINode* slice_start_index_adjusted_phi =
+              ir_builder_->CreatePHI(slice_start_index_adjusted_oob->getType(),
+                                     2);
+          slice_start_index_adjusted_phi->addIncoming(
+              slice_start_index_adjusted_oob,
+              if_start_needs_adjustment.true_block);
+          slice_start_index_adjusted_phi->addIncoming(
+              slice_start_index[i], if_start_needs_adjustment.false_block);
+          // End of if within if.
+
+          // After checking in/out of bounds.
+          SetToFirstInsertPoint(if_in_bounds.after_block, ir_builder_);
+          llvm::PHINode* phi_slice_intersection =
+              ir_builder_->CreatePHI(slice_intersection->getType(), 2);
+          phi_slice_intersection->addIncoming(slice_intersection_in_bounds,
+                                              if_in_bounds.true_block);
+          phi_slice_intersection->addIncoming(
+              slice_intersection_out_of_bounds,
+              if_start_needs_adjustment.after_block);
+          slice_intersection = phi_slice_intersection;
+
+          llvm::PHINode* phi_index =
+              ir_builder_->CreatePHI(slice_start_index[i]->getType(), 2);
+          phi_index->addIncoming(slice_start_index[i], if_in_bounds.true_block);
+          phi_index->addIncoming(slice_start_index_adjusted_phi,
+                                 if_start_needs_adjustment.after_block);
+          slice_start_index_adjusted[i] = phi_index;
         }
 
         // Emit:
         // if (slice_intersection) -> return data from 'update'.
-        // else                    -> return data from 'index'.
+        // else                    -> return data from 'input'.
         llvm::Value* ret_value_addr = llvm_ir::EmitAllocaAtFunctionEntry(
             llvm_ir::PrimitiveTypeToIrType(hlo->shape().element_type(),
                                            module_),
@@ -1337,7 +1405,7 @@ llvm_ir::ElementGenerator ElementalIrEmitter::MakeElementGenerator(
         llvm_ir::LlvmIfData if_data = llvm_ir::EmitIfThenElse(
             slice_intersection, "slice_intersection", ir_builder_);
 
-        // Handle true BB.
+        // Handle true BB (return data from 'update')
         SetToFirstInsertPoint(if_data.true_block, ir_builder_);
         // Compute update index for intersection case.
         llvm_ir::IrArray::Index update_index(rank);
@@ -1346,14 +1414,14 @@ llvm_ir::ElementGenerator ElementalIrEmitter::MakeElementGenerator(
               index[i]->getType(), update_hlo->shape().dimensions(i));
           // NOTE: Subtraction will be positive due to bounds checking above.
           update_index[i] = ir_builder_->CreateURem(
-              ir_builder_->CreateSub(index[i], slice_start_index[i]),
+              ir_builder_->CreateSub(index[i], slice_start_index_adjusted[i]),
               update_dim_size);
         }
         TF_ASSIGN_OR_RETURN(llvm::Value * true_value,
                             operand_to_generator.at(update_hlo)(update_index));
         ir_builder_->CreateStore(true_value, ret_value_addr);
 
-        // Handle false BB.
+        // Handle false BB (return data from 'input')
         SetToFirstInsertPoint(if_data.false_block, ir_builder_);
         TF_ASSIGN_OR_RETURN(llvm::Value * false_value,
                             operand_to_generator.at(input_hlo)(index));
diff --git a/tensorflow/compiler/xla/service/executable.h b/tensorflow/compiler/xla/service/executable.h
index 2d32e59d36c4e3026e0e151561db3076146fabe4..7e0d182b365c35788195e70dc35c3923ed8991bb 100644
--- a/tensorflow/compiler/xla/service/executable.h
+++ b/tensorflow/compiler/xla/service/executable.h
@@ -88,6 +88,16 @@ class Executable {
           tensorflow::gtl::ArraySlice<perftools::gputools::DeviceMemoryBase>>
           arguments);
 
+  // Populates `hlo_execution_profile` from `executor`. This is implicit in any
+  // Execute* API call that takes a hlo_execution_profile argument, but must be
+  // called explicitly for other (async, for example) variants after the stream
+  // has completed.
+  virtual Status PopulateExecutionProfile(
+      HloExecutionProfile* hlo_execution_profile,
+      perftools::gputools::StreamExecutor* executor) {
+    return Status::OK();
+  }
+
   // Convenience wrapper for calling Executable::ExecuteOnStream. Sets up a
   // timer for the execution, sets up HLO profiling if enabled, and fills in the
   // given ExecutionProfile if non-null.  The ExecuteOnStream overloads have
diff --git a/tensorflow/compiler/xla/service/generic_transfer_manager.cc b/tensorflow/compiler/xla/service/generic_transfer_manager.cc
index d3c83ea72e33b959e21d0cc9c1706d92bd659a5c..b4fbed1562945adeb52a9471453ed4fee0e35180 100644
--- a/tensorflow/compiler/xla/service/generic_transfer_manager.cc
+++ b/tensorflow/compiler/xla/service/generic_transfer_manager.cc
@@ -197,7 +197,7 @@ Status GenericTransferManager::ResetDevices(
       "Device reset is not yet supported on this platform (b/30481585)");
 }
 
-int64 GenericTransferManager::GetByteSizeRequirement(const Shape& shape) {
+int64 GenericTransferManager::GetByteSizeRequirement(const Shape& shape) const {
   return ShapeUtil::ByteSizeOf(shape, /*pointer_size=*/sizeof(void*));
 }
 
diff --git a/tensorflow/compiler/xla/service/generic_transfer_manager.h b/tensorflow/compiler/xla/service/generic_transfer_manager.h
index 26488d6ec651b75c753119a7ce818c692c6c03dd..ef9a50676a4171b56e8a77d2dedc05b1580e5ea5 100644
--- a/tensorflow/compiler/xla/service/generic_transfer_manager.h
+++ b/tensorflow/compiler/xla/service/generic_transfer_manager.h
@@ -78,7 +78,7 @@ class GenericTransferManager : public TransferManager {
       const Shape& shape,
       perftools::gputools::DeviceMemoryBase* region) override;
 
-  int64 GetByteSizeRequirement(const Shape& shape) override;
+  int64 GetByteSizeRequirement(const Shape& shape) const override;
 
  private:
   // The platform this transfer manager targets.
diff --git a/tensorflow/compiler/xla/service/gpu/BUILD b/tensorflow/compiler/xla/service/gpu/BUILD
index b9c4adce93a88cb48635993b6e9999528d78ec07..364b76b93c288f13f2bf447cebfc25f705d77826 100644
--- a/tensorflow/compiler/xla/service/gpu/BUILD
+++ b/tensorflow/compiler/xla/service/gpu/BUILD
@@ -470,6 +470,7 @@ cc_library(
         "//tensorflow/compiler/xla/service/llvm_ir:llvm_util",
         "//tensorflow/core:cuda_libdevice_path",
         "//tensorflow/core:lib",
+        "//tensorflow/core:lib_internal",
         "//tensorflow/core:stream_executor_no_cuda",
         "@llvm//:core",
         "@llvm//:support",
diff --git a/tensorflow/compiler/xla/service/gpu/gpu_compiler.cc b/tensorflow/compiler/xla/service/gpu/gpu_compiler.cc
index 2caa8f60517c66c1708e52481f01727f0008afd9..ceb0e530c151219c7fef4dd6bfa36013cb53d63c 100644
--- a/tensorflow/compiler/xla/service/gpu/gpu_compiler.cc
+++ b/tensorflow/compiler/xla/service/gpu/gpu_compiler.cc
@@ -67,6 +67,7 @@ limitations under the License.
 #include "tensorflow/compiler/xla/types.h"
 #include "tensorflow/compiler/xla/util.h"
 #include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/cleanup.h"
 #include "tensorflow/core/lib/io/path.h"
 #include "tensorflow/core/lib/strings/strcat.h"
 #include "tensorflow/core/platform/cuda_libdevice_path.h"
@@ -226,46 +227,63 @@ tensorflow::Status PrepareHloModuleForIrEmitting(
   return pipeline.Run(hlo_module).status();
 }
 
-// Invokes the ptxas tool on the given PTX string, and dumps its output.
-void DumpPtxasInfo(const string& ptx, int cc_major, int cc_minor) {
+// Compiles the given PTX string using ptxas and returns the resulting machine
+// code (i.e. a cubin) as a byte array.
+StatusOr<std::vector<uint8>> CompilePtx(const string& ptx, int cc_major,
+                                        int cc_minor) {
   const string ptxas_path =
-      tensorflow::io::JoinPath(tensorflow::CudaRoot(), "bin/ptxas");
-  // Do not log PTX stats if ptxas is not found at the given path.
-  if (!tensorflow::Env::Default()->FileExists(ptxas_path).ok()) {
-    LOG(WARNING)
-        << "Failed to dump PTX stats because ptxas is not found at path \""
-        << ptxas_path << "\".";
-    return;
+      tensorflow::io::JoinPath(tensorflow::CudaRoot(), "bin", "ptxas");
+  VLOG(2) << "Using ptxas at " << ptxas_path;
+  auto env = tensorflow::Env::Default();
+  TF_RETURN_IF_ERROR(env->FileExists(ptxas_path));
+
+  // Write ptx into a temporary file.
+  string ptx_path;
+  if (!env->LocalTempFilename(&ptx_path)) {
+    return InternalError("couldn't get temp PTX file name");
   }
+  auto ptx_cleaner = tensorflow::gtl::MakeCleanup([&ptx_path] {
+    TF_CHECK_OK(tensorflow::Env::Default()->DeleteFile(ptx_path));
+  });
 
-  // Write `ptx` into a temporary file.
-  char tempdir_template[] = "/tmp/ptxXXXXXX";
-  char* tempdir_name = mkdtemp(tempdir_template);
-  CHECK_NOTNULL(tempdir_name);
-  string ptx_path = tensorflow::io::JoinPath(tempdir_name, "ptx");
-  TF_CHECK_OK(
-      tensorflow::WriteStringToFile(tensorflow::Env::Default(), ptx_path, ptx));
-  LOG(INFO) << "ptx file written to: " << ptx_path;
+  TF_RETURN_IF_ERROR(tensorflow::WriteStringToFile(env, ptx_path, ptx));
+  VLOG(2) << "ptx written to: " << ptx_path;
 
   // Invoke ptxas and collect its output.
+  string cubin_path;
+  if (!env->LocalTempFilename(&cubin_path)) {
+    return InternalError("couldn't get temp CUBIN file name");
+  }
+  auto cubin_cleaner = tensorflow::gtl::MakeCleanup([&cubin_path] {
+    TF_CHECK_OK(tensorflow::Env::Default()->DeleteFile(cubin_path));
+  });
   tensorflow::SubProcess ptxas_info_dumper;
-  ptxas_info_dumper.SetProgram(ptxas_path,
-                               {ptxas_path, ptx_path, "-o", "/dev/null", "-v",
-                                StrCat("-arch=sm_", cc_major, cc_minor)});
+  std::vector<string> ptxas_args = {ptxas_path, ptx_path, "-o", cubin_path,
+                                    StrCat("-arch=sm_", cc_major, cc_minor)};
+  if (VLOG_IS_ON(2)) {
+    ptxas_args.push_back("-v");
+  }
+  ptxas_info_dumper.SetProgram(ptxas_path, ptxas_args);
   ptxas_info_dumper.SetChannelAction(tensorflow::CHAN_STDERR,
                                      tensorflow::ACTION_PIPE);
   if (!ptxas_info_dumper.Start()) {
-    LOG(ERROR) << "Failed to launch ptxas.";
-    return;
+    return InternalError("Failed to launch ptxas");
   }
   string stderr_output;
   int exit_status = ptxas_info_dumper.Communicate(
       /*stdin_input=*/nullptr, /*stdout_output=*/nullptr, &stderr_output);
   XLA_LOG_LINES(tensorflow::INFO, stderr_output);
   if (exit_status != 0) {
-    LOG(ERROR) << "ptxas exited with non-zero error code " << exit_status
-               << ".";
+    return InternalError("ptxas exited with non-zero error code %d",
+                         exit_status);
   }
+
+  // Read in the result of compilation and return it as a byte vector.
+  string cubin;
+  TF_RETURN_IF_ERROR(tensorflow::ReadFileToString(tensorflow::Env::Default(),
+                                                  cubin_path, &cubin));
+  std::vector<uint8> cubin_vector(cubin.begin(), cubin.end());
+  return cubin_vector;
 }
 
 }  // namespace
@@ -318,7 +336,7 @@ StatusOr<std::unique_ptr<Executable>> GpuCompiler::Compile(
   // BufferAssignment::ToString() includes a header, so no need for us to
   // print one ourselves.
   XLA_VLOG_LINES(2, buffer_assignment->ToString());
-
+  XLA_VLOG_LINES(2, module->ToString());
   const string xla_dump_hlo_proto_to =
       module->config().debug_options().xla_dump_hlo_proto_to();
   if (!xla_dump_hlo_proto_to.empty()) {
@@ -359,15 +377,10 @@ StatusOr<std::unique_ptr<Executable>> GpuCompiler::Compile(
         /*optimized=*/false));
   }
 
-  string* ptx;
   string libdevice_dir;
   {
     tensorflow::mutex_lock lock(mutex_);
 
-    // Reserve space for the PTX to be generated for this module.
-    generated_ptxes_.emplace_back(MakeUnique<string>());
-    ptx = generated_ptxes_.back().get();
-
     // Find the directory containing libdevice.  To avoid searching for it every
     // time, we have a one-element cache, keyed on the module's config's
     // cuda_data_dir.
@@ -389,8 +402,9 @@ StatusOr<std::unique_ptr<Executable>> GpuCompiler::Compile(
     cc_minor = 0;
   }
 
-  TF_ASSIGN_OR_RETURN(*ptx, CompileToPtx(&llvm_module, {cc_major, cc_minor},
-                                         module->config(), libdevice_dir));
+  TF_ASSIGN_OR_RETURN(string ptx,
+                      CompileToPtx(&llvm_module, {cc_major, cc_minor},
+                                   module->config(), libdevice_dir));
 
   if (!ir_dump_directory.empty()) {
     TF_RETURN_IF_ERROR(llvm_ir::DumpIRToDirectory(
@@ -405,10 +419,10 @@ StatusOr<std::unique_ptr<Executable>> GpuCompiler::Compile(
   VLOG(2) << "LLVM module after optimizations:";
   XLA_VLOG_LINES(2, llvm_ir::DumpModuleToString(llvm_module));
   VLOG(2) << "PTX:";
-  XLA_VLOG_LINES(2, *ptx);
-  if (VLOG_IS_ON(2)) {
-    DumpPtxasInfo(*ptx, cc_major, cc_minor);
-  }
+  XLA_VLOG_LINES(2, ptx);
+
+  const std::vector<uint8> cubin =
+      CompilePtxOrGetCachedResult(ptx, cc_major, cc_minor);
 
   auto thunk_schedule = MakeUnique<ThunkSchedule>(
       ir_emitter.ConsumeThunkSequence(), std::move(stream_assignment),
@@ -417,7 +431,8 @@ StatusOr<std::unique_ptr<Executable>> GpuCompiler::Compile(
   XLA_VLOG_LINES(2, thunk_schedule->ToString());
 
   auto* gpu_executable =
-      new GpuExecutable(*ptx, std::move(thunk_schedule), std::move(module),
+      new GpuExecutable(ptx, cubin, {cc_major, cc_minor},
+                        std::move(thunk_schedule), std::move(module),
                         std::move(buffer_assignment), ShapeSizeBytesFunction());
   if (embed_ir_in_executable) {
     DCHECK_NE("", ir_module_string_before_opt);
@@ -426,6 +441,61 @@ StatusOr<std::unique_ptr<Executable>> GpuCompiler::Compile(
   return std::unique_ptr<Executable>(gpu_executable);
 }
 
+std::vector<uint8> GpuCompiler::CompilePtxOrGetCachedResult(const string& ptx,
+                                                            int cc_major,
+                                                            int cc_minor) {
+  bool inserted;
+  decltype(compilation_cache_.begin()) iter;
+  // Pointers into compilation_cache_ where the ptx and (optional) cubin are
+  // stored.
+  const string* cache_ptx = nullptr;
+  CompilationCacheValue* cache_value = nullptr;
+
+  {
+    tensorflow::mutex_lock lock(mutex_);
+    std::tie(iter, inserted) = compilation_cache_.emplace(
+        std::piecewise_construct,
+        std::forward_as_tuple(ptx, cc_major, cc_minor),
+        std::forward_as_tuple());
+    cache_ptx = &iter->first.ptx;
+    cache_value = &iter->second;
+  }
+
+  // Compile the ptx if it wasn't in the cache before we called this function.
+  // Other threads asking for the same compilation key will block on
+  // cache_value->mutex_ until compilation is done.
+  {
+    tensorflow::mutex_lock lock(cache_value->mutex_);
+    if (inserted) {
+      CHECK(!cache_value->compilation_done);
+      if (!ptx.empty()) {
+        StatusOr<std::vector<uint8>> maybe_cubin =
+            CompilePtx(*cache_ptx, cc_major, cc_minor);
+        if (maybe_cubin.ok()) {
+          cache_value->cubin_data = std::move(maybe_cubin).ValueOrDie();
+          VLOG(2) << "Compiled PTX size:" << ptx.size()
+                  << " CUBIN size: " << cache_value->cubin_data.size();
+        } else {
+          LOG(WARNING)
+              << "Failed to compile ptx to cubin.  Will attempt to let "
+                 "GPU driver compile the ptx. "
+              << maybe_cubin.status();
+        }
+      }
+      cache_value->compilation_done = true;
+      cache_value->compilation_done_cv_.notify_all();
+    } else {
+      while (!cache_value->compilation_done) {
+        cache_value->compilation_done_cv_.wait(lock);
+      }
+    }
+  }
+
+  CHECK(cache_value != nullptr);
+  CHECK(cache_value->compilation_done);
+  return cache_value->cubin_data;
+}
+
 StatusOr<std::vector<std::unique_ptr<Executable>>> GpuCompiler::Compile(
     std::vector<std::unique_ptr<HloModule>> modules,
     std::vector<std::vector<se::StreamExecutor*>> stream_execs) {
diff --git a/tensorflow/compiler/xla/service/gpu/gpu_compiler.h b/tensorflow/compiler/xla/service/gpu/gpu_compiler.h
index 7a4c4b00d9ad0d895d6b326d2e58f3becdac56d0..ee67e65caf2434fc74503d07c6fccb98de70d96c 100644
--- a/tensorflow/compiler/xla/service/gpu/gpu_compiler.h
+++ b/tensorflow/compiler/xla/service/gpu/gpu_compiler.h
@@ -26,6 +26,8 @@ limitations under the License.
 #include "tensorflow/compiler/xla/statusor.h"
 #include "tensorflow/compiler/xla/types.h"
 #include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/lib/gtl/optional.h"
+#include "tensorflow/core/lib/hash/hash.h"
 #include "tensorflow/core/platform/macros.h"
 #include "tensorflow/core/platform/mutex.h"
 #include "tensorflow/core/platform/stream_executor_no_cuda.h"
@@ -86,10 +88,57 @@ class GpuCompiler : public LLVMCompiler {
   string cached_cuda_data_dir_ GUARDED_BY(mutex_);
   string cached_libdevice_dir_ GUARDED_BY(mutex_);
 
-  // The list of PTX strings generated by this GpuCompiler. We let GpuCompiler
-  // to own them because they need to be alive across the life span of the
-  // StreamExecutor (b/24776264).
-  std::vector<std::unique_ptr<string>> generated_ptxes_ GUARDED_BY(mutex_);
+  // Tries to compile the given ptx string to cubin.  Returns a vector with the
+  // compiled cubin.  If compilation was unsuccessful, returns an empty vector.
+  std::vector<uint8> CompilePtxOrGetCachedResult(const string& ptx,
+                                                 int cc_major, int cc_minor);
+
+  // The compilation_cache_ map is a cache from {ptx string, cc_major, cc_minor}
+  // -> cubin so we don't recompile the same ptx twice.  This is important for
+  // some interactive workflows.  (We also cache at the HLO level, but sometimes
+  // we can't realize that two modules are the same until we lower to ptx.)
+  //
+  // Compilation of distinct PTX happens in parallel. If more than one thread
+  // attempts to compile the same PTX, the fist thread to obtain
+  // cache_value_->mutex_ performs the compilation. The rest wait() on
+  // cache_value_->compilation_done_cv_ until the compilation is done.
+  //
+  // If compiling the ptx fails, we return an empty cubin, cross our fingers,
+  // and leave compilation up to the driver.
+  struct CompilationCacheKey {
+    CompilationCacheKey(std::string ptx, int cc_major, int cc_minor)
+        : ptx(std::move(ptx)), cc_major(cc_major), cc_minor(cc_minor) {}
+    string ptx;
+    int cc_major;
+    int cc_minor;
+  };
+  struct CompilationCacheHash {
+    size_t operator()(const CompilationCacheKey& key) const {
+      return tensorflow::Hash64Combine(
+          tensorflow::Hash64Combine(tensorflow::Hash64(key.ptx), key.cc_major),
+          key.cc_minor);
+    }
+  };
+  struct CompilationCacheEq {
+    size_t operator()(const CompilationCacheKey& a,
+                      const CompilationCacheKey& b) const {
+      return a.cc_major == b.cc_major && a.cc_minor == b.cc_minor &&
+             a.ptx == b.ptx;
+    }
+  };
+  struct CompilationCacheValue {
+    bool compilation_done = false;
+    std::vector<uint8> cubin_data;
+    // mutex and condition variable to serialize compilation completing.
+    tensorflow::mutex mutex_;
+    tensorflow::condition_variable compilation_done_cv_;
+  };
+
+  // Don't even think about switching this to FlatMap; iterator stability is
+  // critical here.
+  std::unordered_map<CompilationCacheKey, CompilationCacheValue,
+                     CompilationCacheHash, CompilationCacheEq>
+      compilation_cache_ GUARDED_BY(mutex_);
 
   TF_DISALLOW_COPY_AND_ASSIGN(GpuCompiler);
 };
diff --git a/tensorflow/compiler/xla/service/gpu/gpu_executable.cc b/tensorflow/compiler/xla/service/gpu/gpu_executable.cc
index 254d0d770560b32298533f04139ab2f6c9a167ce..c6f23f9b0506186c4f76a887e6a540dafdd79962 100644
--- a/tensorflow/compiler/xla/service/gpu/gpu_executable.cc
+++ b/tensorflow/compiler/xla/service/gpu/gpu_executable.cc
@@ -108,13 +108,16 @@ class HloExecutionProfiler {
 // Implementation note: HLO profiling is always enabled for GPU executables,
 // since we can use timers around thunks.
 GpuExecutable::GpuExecutable(
-    tensorflow::StringPiece ptx,
+    const string& ptx, const std::vector<uint8>& cubin,
+    std::pair<int, int> compute_capability,
     std::unique_ptr<const ThunkSchedule> thunk_schedule,
     std::unique_ptr<const HloModule> hlo_module,
     std::unique_ptr<const BufferAssignment> assignment,
     HloCostAnalysis::ShapeSizeFunction shape_size_function)
     : Executable(std::move(hlo_module)),
       ptx_(ptx),
+      cubin_(cubin),
+      compute_capability_(compute_capability),
       thunk_schedule_(std::move(thunk_schedule)),
       assignment_(std::move(assignment)),
       shape_size_function_(std::move(shape_size_function)) {}
@@ -125,6 +128,16 @@ Status GpuExecutable::ExecuteThunks(
     HloExecutionProfile* hlo_execution_profile) {
   se::Stream* main_stream = run_options->stream();
 
+  std::pair<int, int> stream_compute_compatibility;
+  main_stream->parent()->GetDeviceDescription().cuda_compute_capability(
+      &stream_compute_compatibility.first,
+      &stream_compute_compatibility.second);
+  TF_RET_CHECK(stream_compute_compatibility == compute_capability_)
+      << "Compute capability mismatch; expected {" << compute_capability_.first
+      << ", " << compute_capability_.second << "}, but was {"
+      << stream_compute_compatibility.first << ", "
+      << stream_compute_compatibility.second << "}";
+
   bool do_profile = hlo_execution_profile != nullptr;
   if (do_profile) {
     LOG(WARNING) << "PROFILING: profiling is enabled";
diff --git a/tensorflow/compiler/xla/service/gpu/gpu_executable.h b/tensorflow/compiler/xla/service/gpu/gpu_executable.h
index 748a8f521bc5293d58de19ab52f4bdecec6cb1e5..a3815370c19af1da612bc6d9663cc0f8896062f7 100644
--- a/tensorflow/compiler/xla/service/gpu/gpu_executable.h
+++ b/tensorflow/compiler/xla/service/gpu/gpu_executable.h
@@ -47,7 +47,10 @@ namespace gpu {
 // This is an immutable data type after initialization, and thus thread safe.
 class GpuExecutable : public Executable {
  public:
-  GpuExecutable(tensorflow::StringPiece ptx,
+  // cubin (i.e. the compiled ptx) may be empty, in which case we leave
+  // compilation up to the GPU driver.
+  GpuExecutable(const string& ptx, const std::vector<uint8>& cubin,
+                std::pair<int, int> compute_capability,
                 std::unique_ptr<const ThunkSchedule> thunk_schedule,
                 std::unique_ptr<const HloModule> hlo_module,
                 std::unique_ptr<const BufferAssignment> assignment,
@@ -64,6 +67,13 @@ class GpuExecutable : public Executable {
   // Returns the compiled PTX for the computation.
   tensorflow::StringPiece ptx() const { return ptx_; }
 
+  // Returns the cubin (compiled PTX) stored in this GpuExecutable.  May be
+  // empty, in which case compilation is left up to the GPU driver.
+  const std::vector<uint8>& cubin() const { return cubin_; }
+
+  // Both overloads of ExecuteOnStream will fail if the compute capability of
+  // the stream doesn't match the compute capability passed to this object's
+  // constructor.
   StatusOr<perftools::gputools::DeviceMemoryBase> ExecuteOnStream(
       const ServiceExecutableRunOptions* run_options,
       tensorflow::gtl::ArraySlice<perftools::gputools::DeviceMemoryBase>
@@ -110,8 +120,17 @@ class GpuExecutable : public Executable {
   // This string should be modified only before ExecuteOnStream.
   string ir_module_string_;
 
-  // The reference to the compiled PTX for the computation.
-  const tensorflow::StringPiece ptx_;
+  // The PTX for the computation.
+  const string ptx_;
+
+  // The GPU machine code for the computation, targeting GPUs at
+  // compute_capability_.
+  //
+  // May be empty, in which case we leave compilation up to the GPU driver.
+  const std::vector<uint8> cubin_;
+
+  // The compute capability of the GPU we're targeting with this GpuExecutable.
+  std::pair<int, int> compute_capability_;
 
   // The thunks to be invoked by this GpuExecutable. They are generated by the
   // IrEmitter.
diff --git a/tensorflow/compiler/xla/service/gpu/kernel_thunk.cc b/tensorflow/compiler/xla/service/gpu/kernel_thunk.cc
index 69399e36c4c4faa7c6ed5c79a3f094490f022001..96606993696354f36e143b3b994bbe6afb902df3 100644
--- a/tensorflow/compiler/xla/service/gpu/kernel_thunk.cc
+++ b/tensorflow/compiler/xla/service/gpu/kernel_thunk.cc
@@ -48,6 +48,12 @@ tensorflow::Status KernelThunk::Initialize(const GpuExecutable& executable) {
   // StreamExecutor uses the latter.
   loader_spec_->AddCudaPtxInMemory(
       se::port::StringPiece(ptx.data(), ptx.size()), kernel_name_);
+
+  if (!executable.cubin().empty()) {
+    loader_spec_->AddCudaCubinInMemory(
+        reinterpret_cast<const char*>(executable.cubin().data()), kernel_name_);
+  }
+
   return tensorflow::Status::OK();
 }
 
diff --git a/tensorflow/compiler/xla/service/hlo_instruction.cc b/tensorflow/compiler/xla/service/hlo_instruction.cc
index e09899e48d389716226661c5ae61defb066362aa..5107ac782d7c93dfa17969338bf97c9fd9bb1516 100644
--- a/tensorflow/compiler/xla/service/hlo_instruction.cc
+++ b/tensorflow/compiler/xla/service/hlo_instruction.cc
@@ -1901,12 +1901,13 @@ std::vector<string> HloInstruction::ExtraAttributesToString() const {
   if (has_sharding()) {
     extra.push_back(StrCat("sharding=", sharding().ToString()));
   }
-  if (!control_successors_.empty()) {
-    extra.push_back(StrCat(
-        "control-successors=",
-        Join(control_successors_, ", ", [](string* out, HloInstruction* succ) {
-          StrAppend(out, succ->name());
-        })));
+  if (!control_predecessors_.empty()) {
+    extra.push_back(StrCat("control-predecessors={",
+                           Join(control_predecessors_, ", ",
+                                [](string* out, HloInstruction* pre) {
+                                  StrAppend(out, pre->name());
+                                }),
+                           "}"));
   }
   return extra;
 }
diff --git a/tensorflow/compiler/xla/service/hlo_runner.cc b/tensorflow/compiler/xla/service/hlo_runner.cc
index aaa4e3a2e3a7523a6779f86ba0c20cb48c23f600..f463e57d995c0f0549872a1a0bf20a3ead626dc8 100644
--- a/tensorflow/compiler/xla/service/hlo_runner.cc
+++ b/tensorflow/compiler/xla/service/hlo_runner.cc
@@ -41,11 +41,21 @@ namespace se = ::perftools::gputools;
 namespace xla {
 
 /*static*/ StatusOr<std::unique_ptr<HloModule>>
-HloRunner::ReadModuleFromHloProtoFile(const char* filename,
+HloRunner::ReadModuleFromHloProtoFile(const std::string& filename,
                                       const DebugOptions& debug_options) {
   HloProto proto;
-  TF_RETURN_IF_ERROR(tensorflow::ReadBinaryProto(tensorflow::Env::Default(),
-                                                 filename, &proto));
+
+  const Status s =
+      tensorflow::ReadBinaryProto(tensorflow::Env::Default(), filename, &proto);
+
+  if (!s.ok()) {
+    const Status s2 =
+        tensorflow::ReadTextProto(tensorflow::Env::Default(), filename, &proto);
+    if (!s2.ok()) {
+      return Status(s2.code(), s.error_message() + "\n" + s2.error_message());
+    }
+  }
+
   TF_ASSIGN_OR_RETURN(
       HloModuleConfig config,
       HloModule::CreateModuleConfigFromProto(proto.hlo_module()));
@@ -56,7 +66,7 @@ HloRunner::ReadModuleFromHloProtoFile(const char* filename,
 }
 
 /*static*/ StatusOr<std::unique_ptr<HloModule>>
-HloRunner::ReadModuleFromHloTextDumpFile(const char* filename,
+HloRunner::ReadModuleFromHloTextDumpFile(const std::string& filename,
                                          const DebugOptions& debug_options) {
   string hlo_string;
   TF_RETURN_IF_ERROR(tensorflow::ReadFileToString(tensorflow::Env::Default(),
@@ -66,6 +76,19 @@ HloRunner::ReadModuleFromHloTextDumpFile(const char* filename,
   return tools::Parse(hlo_string, config);
 }
 
+/*static*/ StatusOr<std::unique_ptr<HloModule>> HloRunner::ReadModule(
+    const std::string& filename, const DebugOptions& debug_options) {
+  auto module = HloRunner::ReadModuleFromHloProtoFile(filename, debug_options);
+  if (module.ok()) {
+    return module;
+  }
+  const std::string e = module.status().error_message();
+  module = HloRunner::ReadModuleFromHloTextDumpFile(filename, debug_options);
+  return module.ok() ? std::move(module)
+                     : Status(module.status().code(),
+                              e + "\n" + module.status().error_message());
+}
+
 // Define this in .cc file to avoid having to include eigen or forward declare
 // these types in the header.
 struct HloRunner::EigenThreadPoolWrapper {
diff --git a/tensorflow/compiler/xla/service/hlo_runner.h b/tensorflow/compiler/xla/service/hlo_runner.h
index b0e2b980e22d3348f63a528cd49f0b814540d549..a5732848c6b4191faf8d7b07c749132ca8b14413 100644
--- a/tensorflow/compiler/xla/service/hlo_runner.h
+++ b/tensorflow/compiler/xla/service/hlo_runner.h
@@ -44,15 +44,23 @@ class HloRunner {
 
   ~HloRunner();
 
-  // Reads the binary proto file in xla.HloProto format, creates and returns the
-  // HloModule.
+  // Reads the proto file in xla.HloProto format, creates and returns the
+  // HloModule. Will try to parse the filename as binary proto, then try as
+  // text proto if that fails.
   static StatusOr<std::unique_ptr<HloModule>> ReadModuleFromHloProtoFile(
-      const char* filename, const DebugOptions& debug_options);
+      const std::string& filename, const DebugOptions& debug_options);
 
   // Reads the hlo text dump file in HloModule::ToString format, creates and
   // returns the HloModule.
   static StatusOr<std::unique_ptr<HloModule>> ReadModuleFromHloTextDumpFile(
-      const char* filename, const DebugOptions& debug_options);
+      const std::string& filename, const DebugOptions& debug_options);
+
+  // Tries to parse the filename specified first as binary proto format, then
+  // as a textual proto format, then textual IR, then gives up if both fail.
+  // ReadModuleFromHloProtoFile or ReadModuleFromHloTextDumpFile should be used
+  // explicitly when you know the format, this if you don't.
+  static StatusOr<std::unique_ptr<HloModule>> ReadModule(
+      const std::string& filename, const DebugOptions& debug_options);
 
   // Executes the given module with given literals as input and returns the
   // result as a Literal. The LiteralPtr type accepts Literal* or
diff --git a/tensorflow/compiler/xla/service/llvm_ir/llvm_util.cc b/tensorflow/compiler/xla/service/llvm_ir/llvm_util.cc
index 5dff4b5778970dd473c5f158b3828a850847d1ff..956c0d5f05288e32c626f247ce8356c60d17808d 100644
--- a/tensorflow/compiler/xla/service/llvm_ir/llvm_util.cc
+++ b/tensorflow/compiler/xla/service/llvm_ir/llvm_util.cc
@@ -555,8 +555,9 @@ int64 ByteSizeOf(const Shape& shape, const llvm::DataLayout& data_layout) {
 llvm::FastMathFlags GetFastMathFlags(bool fast_math_enabled) {
   llvm::FastMathFlags flags;
   if (fast_math_enabled) {
-    // UnsafeAlgebra implies NoInfs, NoNaNs, NoSignedZeros, and AllowReciprocal.
-    flags.setUnsafeAlgebra();
+    // Fast implies AllowReassoc, NoInfs, NoNaNs, NoSignedZeros,
+    // AllowReciprocal, AllowContract, and ApproxFunc.
+    flags.setFast();
   }
   return flags;
 }
diff --git a/tensorflow/compiler/xla/service/service.cc b/tensorflow/compiler/xla/service/service.cc
index bac33d8102e07766531a4ce6eac77aff4971bfef..71afbee456b0f5eb67cb092d84f8e95ea1038c54 100644
--- a/tensorflow/compiler/xla/service/service.cc
+++ b/tensorflow/compiler/xla/service/service.cc
@@ -490,14 +490,20 @@ Service::ExecuteParallelAndRegisterResult(
         std::vector<perftools::gputools::DeviceMemoryBase>>
         arguments,
     Backend* backend, tensorflow::gtl::ArraySlice<DeviceHandle> device_handles,
-    tensorflow::gtl::ArraySlice<string> result_tags) {
+    tensorflow::gtl::ArraySlice<string> result_tags,
+    ExecutionProfile* profile) {
   // Streams where the computation are launched, so we can wait on the streams
   // to complete.
   std::vector<Pool<se::Stream>::SmartPtr> streams;
+  std::vector<std::unique_ptr<perftools::gputools::Timer>> timers;
 
   // Global data handles for the computation results, one for each computation.
   std::vector<GlobalDataHandle> result_handles;
 
+  // Device ID to stream executor, populated only with devices that are being
+  // profiled.
+  std::map<int64, se::Stream*> index_to_profiled_streams;
+
   TF_ASSIGN_OR_RETURN(DeviceAssignment device_assignment,
                       backend->computation_placer()->AssignDevices(
                           options_.number_of_replicas(), executables.size()));
@@ -510,6 +516,21 @@ Service::ExecuteParallelAndRegisterResult(
                           backend->BorrowStream(replicas[replica]));
       streams.push_back(std::move(stream));
 
+      if (replica == 0 && profile != nullptr) {
+        timers.emplace_back(
+            new perftools::gputools::Timer(streams.back()->parent()));
+        streams.back()
+            ->InitTimer(timers.back().get())
+            .ThenStartTimer(timers.back().get());
+        CHECK(timers.front() != nullptr);
+      }
+
+      if (replica == 0 &&
+          executables[i]->module_config().debug_options().xla_hlo_profile() &&
+          executables[i]->hlo_profiling_enabled()) {
+        index_to_profiled_streams[i] = streams.back().get();
+      }
+
       // Set up run options.
       ExecutableRunOptions options;
       options.set_stream(streams.back().get());
@@ -526,6 +547,10 @@ Service::ExecuteParallelAndRegisterResult(
           perftools::gputools::DeviceMemoryBase result,
           executables[i]->ExecuteAsyncOnStream(&run_options, arguments[i]));
 
+      if (replica == 0 && profile != nullptr) {
+        streams.back()->ThenStopTimer(timers.back().get());
+      }
+
       // All replicas share the same device address for the result allocation,
       // so only one of the replicas need to register the result handle.
       if (replica == 0) {
@@ -543,6 +568,69 @@ Service::ExecuteParallelAndRegisterResult(
     }
   }
 
+  // For every stream that had profiling enabled, obtain and debug-dump the HLO
+  // profile.
+  for (auto& index_to_profiled_stream : index_to_profiled_streams) {
+    int64 device = index_to_profiled_stream.first;
+    se::Stream* stream = index_to_profiled_stream.second;
+    HloExecutionProfile hlo_profile;
+    TF_RETURN_IF_ERROR(executables[device]->PopulateExecutionProfile(
+        &hlo_profile, stream->parent()));
+
+    std::unordered_set<const xla::HloComputation*> profiled_computations =
+        hlo_profile.profiled_computations();
+    // To ensure we have print the profiles in a stable order, iterate over the
+    // computations in post order.
+    auto& module = executables[device]->module();
+    std::list<xla::HloComputation*> all_computations =
+        module.MakeComputationPostOrder();
+    for (xla::HloComputation* computation : all_computations) {
+      if (profiled_computations.count(computation) > 0) {
+        string profile_string = hlo_profile.ToString(
+            *computation, streams[0]->parent()->GetDeviceDescription(),
+            executables[device]->CreateCostAnalysis().get());
+        if (!profile_string.empty()) {
+          LOG(INFO) << "HLO profile for execution on device " << device
+                    << ":\n";
+          XLA_LOG_LINES(tensorflow::INFO, profile_string);
+        }
+      }
+    }
+    hlo_graph_dumper::MaybeDumpHloModule(module, "Service::Execute",
+                                         &hlo_profile);
+  }
+
+  if (profile != nullptr) {
+    CHECK(!timers.empty());
+    std::vector<uint64> timer_nanoseconds;
+    timer_nanoseconds.reserve(timers.size());
+    for (auto& timer : timers) {
+      timer_nanoseconds.push_back(timer->Nanoseconds());
+    }
+    uint64 nanoseconds =
+        *std::max_element(timer_nanoseconds.begin(), timer_nanoseconds.end());
+
+    // Merge in run-time profile information from execution_profile on the
+    // zeroth device.
+    profile->MergeFrom(executables[0]->execution_profile());
+
+    // Overall execution time (in nanoseconds) from the executor timer.
+    profile->set_compute_and_transfer_time_ns(nanoseconds);
+
+    // TODO(b/28123297): On GPU we end up including transfer time in
+    // the compute time this way. Instead, we should get the correct
+    // value by measuring it. Setting the field here at least lets
+    // benchmarks provide *some* value for GPU computations.
+    //
+    // TODO(b/28447609): The value in compute_and_transfer_time_ns is actually
+    // the compute time without the transfer time, so this way we get the
+    // correct compute time. We should instead have the correct value for
+    // compute_and_transfer_time and set compute_time to the compute time.
+    if (profile->compute_time_ns() == 0) {
+      profile->set_compute_time_ns(profile->compute_and_transfer_time_ns());
+    }
+  }
+
   return result_handles;
 }
 
@@ -715,14 +803,16 @@ tensorflow::Status Service::ExecuteParallel(const ExecuteParallelRequest* arg,
 
   // Execute the generated executables in parallel and return the device
   // handles for each computation's output.
+  ExecutionProfile profile;
   TF_ASSIGN_OR_RETURN(
       std::vector<GlobalDataHandle> outputs,
       ExecuteParallelAndRegisterResult(executable_ptrs, all_arguments,
                                        execute_backend_.get(), device_handles,
-                                       computation_names));
+                                       computation_names, &profile));
   for (const GlobalDataHandle& output : outputs) {
     ExecuteResponse response;
     *response.mutable_output() = output;
+    *response.mutable_profile() = profile;
     *result->add_responses() = response;
   }
 
@@ -1082,8 +1172,9 @@ tensorflow::Status Service::IsConstant(const IsConstantRequest* arg,
     return InvalidArgument("computations may not be empty");
   }
 
-  TF_ASSIGN_OR_RETURN(bool is_constant,
-                      user_computation->IsConstant(arg->operand()));
+  TF_ASSIGN_OR_RETURN(
+      bool is_constant,
+      user_computation->IsConstant(arg->operand(), arg->num_parameters()));
 
   result->set_is_constant(is_constant);
   return tensorflow::Status::OK();
@@ -1101,8 +1192,9 @@ tensorflow::Status Service::ComputeConstant(const ComputeConstantRequest* arg,
     return InvalidArgument("computations may not be empty");
   }
 
-  TF_ASSIGN_OR_RETURN(bool is_constant,
-                      user_computation->IsConstant(arg->operand()));
+  TF_ASSIGN_OR_RETURN(
+      bool is_constant,
+      user_computation->IsConstant(arg->operand(), arg->parameters_size()));
   if (!is_constant) {
     return InvalidArgument("Operand to ComputeConstant depends on parameter.");
   }
@@ -1141,8 +1233,18 @@ tensorflow::Status Service::ComputeConstant(const ComputeConstantRequest* arg,
                                           /*include_unreachable_instructions=*/
                                           false));
 
+  std::vector<Literal> parameters(arg->parameters_size());
+  for (int64 i = 0; i < arg->parameters_size(); ++i) {
+    parameters[i] = Literal(arg->parameters(i));
+  }
+  std::vector<const Literal*> parameter_ptrs;
+  std::transform(parameters.begin(), parameters.end(),
+                 std::back_inserter(parameter_ptrs),
+                 [](const Literal& literal) { return &literal; });
+
   HloEvaluator evaluator;
-  TF_ASSIGN_OR_RETURN(auto result_literal, evaluator.Evaluate(*module, {}));
+  TF_ASSIGN_OR_RETURN(auto result_literal,
+                      evaluator.Evaluate(*module, parameter_ptrs));
   // Since the shape_with_output_layout option in ExecutionOption is
   // non-effective to the Evaluator results, explicit relayout here.
   if (arg->has_output_layout()) {
diff --git a/tensorflow/compiler/xla/service/service.h b/tensorflow/compiler/xla/service/service.h
index 2452259f736054b5bf1f03fc5103d65eded7f398..6646be2e9aa43763b93bcea7a1df9d10580f162c 100644
--- a/tensorflow/compiler/xla/service/service.h
+++ b/tensorflow/compiler/xla/service/service.h
@@ -327,7 +327,8 @@ class Service : public ServiceInterface {
           arguments,
       Backend* backend,
       tensorflow::gtl::ArraySlice<DeviceHandle> device_handles,
-      tensorflow::gtl::ArraySlice<string> result_tags);
+      tensorflow::gtl::ArraySlice<string> result_tags,
+      ExecutionProfile* profile);
 
   // Convenience function for adding a function to a user computation.
   template <typename RequestT, typename ResponseT>
diff --git a/tensorflow/compiler/xla/service/transfer_manager.h b/tensorflow/compiler/xla/service/transfer_manager.h
index f63d91604cf40edfae98b56a8bacdbded697ffc3..057bdffe93164e9bb7271157556961575666359d 100644
--- a/tensorflow/compiler/xla/service/transfer_manager.h
+++ b/tensorflow/compiler/xla/service/transfer_manager.h
@@ -119,7 +119,7 @@ class TransferManager {
   // Determines the byte size requirement for the given shape on the underlying
   // architecture. This will be used to allocate an appropriately sized memory
   // region for a host-to-device transfer.
-  virtual int64 GetByteSizeRequirement(const Shape& shape) = 0;
+  virtual int64 GetByteSizeRequirement(const Shape& shape) const = 0;
 
   // Transfer a memory block of the given size from the device source into the
   // 'destination' buffer.
diff --git a/tensorflow/compiler/xla/service/user_computation.cc b/tensorflow/compiler/xla/service/user_computation.cc
index 006c814996df9b209e6cd4d75bc04689c4e297c5..e9d182509b5356d32b667b7921e2843d30faeb9b 100644
--- a/tensorflow/compiler/xla/service/user_computation.cc
+++ b/tensorflow/compiler/xla/service/user_computation.cc
@@ -1482,14 +1482,15 @@ UserComputation::ComputeProgramShape(
 
 namespace {
 
-// A visitor which checks whether an operation is a compile-time constant. That
-// is, the operation does not depend on any parameter instructions. The visitor
-// walks the computation starting at a given operation and sets is_constant to
-// false iff a parameter or RNG operation is encountered.
-void ConstantVisitor(const SessionComputation& session_computation,
-                     const ComputationDataHandle& handle,
-                     std::set<int64>* visited, bool* is_constant) {
-  if (visited->count(handle.handle()) != 0 || !*is_constant) {
+// A visitor which checks whether an operation is pure functional meaning that
+// it doesn't depend on any parameter with an index higher then num_parameters.
+// The visitor walks the computation starting at a given operation and sets
+// is_functional to false iff a parameter or RNG operation is encountered.
+void PureFunctionalVisitor(const SessionComputation& session_computation,
+                           const ComputationDataHandle& handle,
+                           int64 num_parameters, std::set<int64>* visited,
+                           bool* is_functional) {
+  if (visited->count(handle.handle()) != 0 || !*is_functional) {
     return;
   }
 
@@ -1497,7 +1498,7 @@ void ConstantVisitor(const SessionComputation& session_computation,
       session_computation.requests().at(handle.handle());
   switch (request.request().op_case()) {
     case OpRequest::kRngRequest:
-      *is_constant = false;
+      *is_functional = false;
       break;
 
     case OpRequest::kConstantRequest:
@@ -1506,41 +1507,43 @@ void ConstantVisitor(const SessionComputation& session_computation,
     case OpRequest::kGetTupleElementRequest: {
       const GetTupleElementRequest& get_tuple_element_request =
           request.request().get_tuple_element_request();
-      ConstantVisitor(session_computation, get_tuple_element_request.operand(),
-                      visited, is_constant);
+      PureFunctionalVisitor(session_computation,
+                            get_tuple_element_request.operand(), num_parameters,
+                            visited, is_functional);
       break;
     }
 
     case OpRequest::kSliceRequest: {
       const SliceRequest& slice_request = request.request().slice_request();
-      ConstantVisitor(session_computation, slice_request.operand(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation, slice_request.operand(),
+                            num_parameters, visited, is_functional);
       break;
     }
 
     case OpRequest::kDynamicSliceRequest: {
       const DynamicSliceRequest& dynamic_slice_request =
           request.request().dynamic_slice_request();
-      ConstantVisitor(session_computation, dynamic_slice_request.operand(),
-                      visited, is_constant);
-      ConstantVisitor(session_computation,
-                      dynamic_slice_request.start_indices(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation,
+                            dynamic_slice_request.operand(), num_parameters,
+                            visited, is_functional);
+      PureFunctionalVisitor(session_computation,
+                            dynamic_slice_request.start_indices(),
+                            num_parameters, visited, is_functional);
       break;
     }
 
     case OpRequest::kDynamicUpdateSliceRequest: {
       const DynamicUpdateSliceRequest& dynamic_update_slice_request =
           request.request().dynamic_update_slice_request();
-      ConstantVisitor(session_computation,
-                      dynamic_update_slice_request.operand(), visited,
-                      is_constant);
-      ConstantVisitor(session_computation,
-                      dynamic_update_slice_request.update(), visited,
-                      is_constant);
-      ConstantVisitor(session_computation,
-                      dynamic_update_slice_request.start_indices(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation,
+                            dynamic_update_slice_request.operand(),
+                            num_parameters, visited, is_functional);
+      PureFunctionalVisitor(session_computation,
+                            dynamic_update_slice_request.update(),
+                            num_parameters, visited, is_functional);
+      PureFunctionalVisitor(session_computation,
+                            dynamic_update_slice_request.start_indices(),
+                            num_parameters, visited, is_functional);
       break;
     }
 
@@ -1549,7 +1552,8 @@ void ConstantVisitor(const SessionComputation& session_computation,
           request.request().concatenate_request();
       for (const ComputationDataHandle& handle :
            concatenate_request.operands()) {
-        ConstantVisitor(session_computation, handle, visited, is_constant);
+        PureFunctionalVisitor(session_computation, handle, num_parameters,
+                              visited, is_functional);
       }
       break;
     }
@@ -1557,61 +1561,63 @@ void ConstantVisitor(const SessionComputation& session_computation,
     case OpRequest::kConvolveRequest: {
       const ConvolveRequest& convolve_request =
           request.request().convolve_request();
-      ConstantVisitor(session_computation, convolve_request.lhs(), visited,
-                      is_constant);
-      ConstantVisitor(session_computation, convolve_request.rhs(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation, convolve_request.lhs(),
+                            num_parameters, visited, is_functional);
+      PureFunctionalVisitor(session_computation, convolve_request.rhs(),
+                            num_parameters, visited, is_functional);
       break;
     }
 
     case OpRequest::kCrossReplicaSumRequest: {
       // TODO(b/33009255): Implmement constant folding for cross replica sum.
-      *is_constant = false;
+      *is_functional = false;
       break;
     }
 
     case OpRequest::kInfeedRequest: {
-      *is_constant = false;
+      *is_functional = false;
       break;
     }
 
     case OpRequest::kOutfeedRequest: {
-      *is_constant = false;
+      *is_functional = false;
       break;
     }
 
     case OpRequest::kCallRequest: {
       const CallRequest& call_request = request.request().call_request();
       for (const ComputationDataHandle& handle : call_request.operands()) {
-        ConstantVisitor(session_computation, handle, visited, is_constant);
+        PureFunctionalVisitor(session_computation, handle, num_parameters,
+                              visited, is_functional);
       }
       // TODO(b/32495713): We aren't checking the to_apply computation itself,
       // so we conservatively say that computations containing the Call op
-      // cannot be constant.  We cannot set is_constant=false in other similar
+      // cannot be constant.  We cannot set is_functional=false in other similar
       // cases since we're already relying on IsConstant to return true.
-      *is_constant = false;
+      *is_functional = false;
       break;
     }
 
     case OpRequest::kCustomCallRequest: {
-      *is_constant = false;
+      *is_functional = false;
       break;
     }
 
     case OpRequest::kSendRequest: {
-      *is_constant = false;
+      *is_functional = false;
       break;
     }
 
     case OpRequest::kRecvRequest: {
-      *is_constant = false;
+      *is_functional = false;
       break;
     }
 
     case OpRequest::kMapRequest: {
       const MapRequest& map_request = request.request().map_request();
       for (const ComputationDataHandle& handle : map_request.operands()) {
-        ConstantVisitor(session_computation, handle, visited, is_constant);
+        PureFunctionalVisitor(session_computation, handle, num_parameters,
+                              visited, is_functional);
       }
       // TODO(b/32495713): We aren't checking the to_apply computation itself.
       break;
@@ -1619,10 +1625,10 @@ void ConstantVisitor(const SessionComputation& session_computation,
 
     case OpRequest::kReduceRequest: {
       const ReduceRequest& reduce_request = request.request().reduce_request();
-      ConstantVisitor(session_computation, reduce_request.operand(), visited,
-                      is_constant);
-      ConstantVisitor(session_computation, reduce_request.init_value(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation, reduce_request.operand(),
+                            num_parameters, visited, is_functional);
+      PureFunctionalVisitor(session_computation, reduce_request.init_value(),
+                            num_parameters, visited, is_functional);
       // TODO(b/32495713): We aren't checking the to_apply computation itself.
       break;
     }
@@ -1630,10 +1636,12 @@ void ConstantVisitor(const SessionComputation& session_computation,
     case OpRequest::kReduceWindowRequest: {
       const ReduceWindowRequest& reduce_window_request =
           request.request().reduce_window_request();
-      ConstantVisitor(session_computation, reduce_window_request.operand(),
-                      visited, is_constant);
-      ConstantVisitor(session_computation, reduce_window_request.init_value(),
-                      visited, is_constant);
+      PureFunctionalVisitor(session_computation,
+                            reduce_window_request.operand(), num_parameters,
+                            visited, is_functional);
+      PureFunctionalVisitor(session_computation,
+                            reduce_window_request.init_value(), num_parameters,
+                            visited, is_functional);
       // TODO(b/32495713): We aren't checking the to_apply computation itself.
       break;
     }
@@ -1641,13 +1649,15 @@ void ConstantVisitor(const SessionComputation& session_computation,
     case OpRequest::kSelectAndScatterRequest: {
       const SelectAndScatterRequest& select_and_scatter_request =
           request.request().select_and_scatter_request();
-      ConstantVisitor(session_computation, select_and_scatter_request.operand(),
-                      visited, is_constant);
-      ConstantVisitor(session_computation, select_and_scatter_request.source(),
-                      visited, is_constant);
-      ConstantVisitor(session_computation,
-                      select_and_scatter_request.init_value(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation,
+                            select_and_scatter_request.operand(),
+                            num_parameters, visited, is_functional);
+      PureFunctionalVisitor(session_computation,
+                            select_and_scatter_request.source(), num_parameters,
+                            visited, is_functional);
+      PureFunctionalVisitor(session_computation,
+                            select_and_scatter_request.init_value(),
+                            num_parameters, visited, is_functional);
       // TODO(b/32495713): We aren't checking the select and scatter
       // computations themselves.
       break;
@@ -1656,76 +1666,80 @@ void ConstantVisitor(const SessionComputation& session_computation,
     case OpRequest::kBroadcastRequest: {
       const BroadcastRequest& broadcast_request =
           request.request().broadcast_request();
-      ConstantVisitor(session_computation, broadcast_request.operand(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation, broadcast_request.operand(),
+                            num_parameters, visited, is_functional);
       break;
     }
 
     case OpRequest::kReshapeRequest: {
       const ReshapeRequest& reshape_request =
           request.request().reshape_request();
-      ConstantVisitor(session_computation, reshape_request.operand(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation, reshape_request.operand(),
+                            num_parameters, visited, is_functional);
       break;
     }
 
     case OpRequest::kReverseRequest: {
       const ReverseRequest& reverse_request =
           request.request().reverse_request();
-      ConstantVisitor(session_computation, reverse_request.operand(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation, reverse_request.operand(),
+                            num_parameters, visited, is_functional);
       break;
     }
 
     case OpRequest::kPadRequest: {
       const PadRequest& pad_request = request.request().pad_request();
-      ConstantVisitor(session_computation, pad_request.operand(), visited,
-                      is_constant);
-      ConstantVisitor(session_computation, pad_request.padding_value(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation, pad_request.operand(),
+                            num_parameters, visited, is_functional);
+      PureFunctionalVisitor(session_computation, pad_request.padding_value(),
+                            num_parameters, visited, is_functional);
       break;
     }
 
     case OpRequest::kParameterRequest: {
-      *is_constant = false;
+      const ParameterRequest& parameter_request =
+          request.request().parameter_request();
+      if (parameter_request.parameter() >= num_parameters) {
+        *is_functional = false;
+      }
       break;
     }
 
     case OpRequest::kConvertRequest: {
       const ConvertRequest& convert_request =
           request.request().convert_request();
-      ConstantVisitor(session_computation, convert_request.operand(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation, convert_request.operand(),
+                            num_parameters, visited, is_functional);
       break;
     }
 
     case OpRequest::kWhileRequest: {
       const WhileRequest& while_request = request.request().while_request();
-      ConstantVisitor(session_computation, while_request.init(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation, while_request.init(),
+                            num_parameters, visited, is_functional);
       // TODO(b/32495713): We aren't checking the condition and body
       // computations themselves.
-      *is_constant = false;
+      *is_functional = false;
       break;
     }
 
     case OpRequest::kTernaryOpRequest: {
       const TernaryOpRequest& ternary_op_request =
           request.request().ternary_op_request();
-      ConstantVisitor(session_computation, ternary_op_request.lhs(), visited,
-                      is_constant);
-      ConstantVisitor(session_computation, ternary_op_request.rhs(), visited,
-                      is_constant);
-      ConstantVisitor(session_computation, ternary_op_request.ehs(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation, ternary_op_request.lhs(),
+                            num_parameters, visited, is_functional);
+      PureFunctionalVisitor(session_computation, ternary_op_request.rhs(),
+                            num_parameters, visited, is_functional);
+      PureFunctionalVisitor(session_computation, ternary_op_request.ehs(),
+                            num_parameters, visited, is_functional);
       break;
     }
 
     case OpRequest::kTransposeRequest: {
       const TransposeRequest& transpose_request =
           request.request().transpose_request();
-      ConstantVisitor(session_computation, transpose_request.operand(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation, transpose_request.operand(),
+                            num_parameters, visited, is_functional);
       break;
     }
 
@@ -1734,7 +1748,8 @@ void ConstantVisitor(const SessionComputation& session_computation,
           request.request().variadic_op_request();
       for (const ComputationDataHandle& handle :
            variadic_op_request.operands()) {
-        ConstantVisitor(session_computation, handle, visited, is_constant);
+        PureFunctionalVisitor(session_computation, handle, num_parameters,
+                              visited, is_functional);
       }
       break;
     }
@@ -1742,67 +1757,74 @@ void ConstantVisitor(const SessionComputation& session_computation,
     case OpRequest::kUnaryOpRequest: {
       const UnaryOpRequest& unary_op_request =
           request.request().unary_op_request();
-      ConstantVisitor(session_computation, unary_op_request.operand(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation, unary_op_request.operand(),
+                            num_parameters, visited, is_functional);
       break;
     }
 
     case OpRequest::kBatchNormTrainingRequest: {
       const BatchNormTrainingRequest& batch_norm_training_request =
           request.request().batch_norm_training_request();
-      ConstantVisitor(session_computation,
-                      batch_norm_training_request.operand(), visited,
-                      is_constant);
-      ConstantVisitor(session_computation, batch_norm_training_request.scale(),
-                      visited, is_constant);
-      ConstantVisitor(session_computation, batch_norm_training_request.offset(),
-                      visited, is_constant);
+      PureFunctionalVisitor(session_computation,
+                            batch_norm_training_request.operand(),
+                            num_parameters, visited, is_functional);
+      PureFunctionalVisitor(session_computation,
+                            batch_norm_training_request.scale(), num_parameters,
+                            visited, is_functional);
+      PureFunctionalVisitor(session_computation,
+                            batch_norm_training_request.offset(),
+                            num_parameters, visited, is_functional);
       break;
     }
 
     case OpRequest::kBatchNormInferenceRequest: {
       const BatchNormInferenceRequest& batch_norm_inference_request =
           request.request().batch_norm_inference_request();
-      ConstantVisitor(session_computation,
-                      batch_norm_inference_request.operand(), visited,
-                      is_constant);
-      ConstantVisitor(session_computation, batch_norm_inference_request.scale(),
-                      visited, is_constant);
-      ConstantVisitor(session_computation,
-                      batch_norm_inference_request.offset(), visited,
-                      is_constant);
-      ConstantVisitor(session_computation, batch_norm_inference_request.mean(),
-                      visited, is_constant);
-      ConstantVisitor(session_computation,
-                      batch_norm_inference_request.variance(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation,
+                            batch_norm_inference_request.operand(),
+                            num_parameters, visited, is_functional);
+      PureFunctionalVisitor(session_computation,
+                            batch_norm_inference_request.scale(),
+                            num_parameters, visited, is_functional);
+      PureFunctionalVisitor(session_computation,
+                            batch_norm_inference_request.offset(),
+                            num_parameters, visited, is_functional);
+      PureFunctionalVisitor(session_computation,
+                            batch_norm_inference_request.mean(), num_parameters,
+                            visited, is_functional);
+      PureFunctionalVisitor(session_computation,
+                            batch_norm_inference_request.variance(),
+                            num_parameters, visited, is_functional);
       break;
     }
 
     case OpRequest::kBatchNormGradRequest: {
       const BatchNormGradRequest& batch_norm_grad_request =
           request.request().batch_norm_grad_request();
-      ConstantVisitor(session_computation, batch_norm_grad_request.operand(),
-                      visited, is_constant);
-      ConstantVisitor(session_computation, batch_norm_grad_request.scale(),
-                      visited, is_constant);
-      ConstantVisitor(session_computation, batch_norm_grad_request.mean(),
-                      visited, is_constant);
-      ConstantVisitor(session_computation, batch_norm_grad_request.variance(),
-                      visited, is_constant);
-      ConstantVisitor(session_computation,
-                      batch_norm_grad_request.grad_output(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation,
+                            batch_norm_grad_request.operand(), num_parameters,
+                            visited, is_functional);
+      PureFunctionalVisitor(session_computation,
+                            batch_norm_grad_request.scale(), num_parameters,
+                            visited, is_functional);
+      PureFunctionalVisitor(session_computation, batch_norm_grad_request.mean(),
+                            num_parameters, visited, is_functional);
+      PureFunctionalVisitor(session_computation,
+                            batch_norm_grad_request.variance(), num_parameters,
+                            visited, is_functional);
+      PureFunctionalVisitor(session_computation,
+                            batch_norm_grad_request.grad_output(),
+                            num_parameters, visited, is_functional);
       break;
     }
 
     case OpRequest::kBinaryOpRequest: {
       const BinaryOpRequest& binary_op_request =
           request.request().binary_op_request();
-      ConstantVisitor(session_computation, binary_op_request.lhs(), visited,
-                      is_constant);
-      ConstantVisitor(session_computation, binary_op_request.rhs(), visited,
-                      is_constant);
+      PureFunctionalVisitor(session_computation, binary_op_request.lhs(),
+                            num_parameters, visited, is_functional);
+      PureFunctionalVisitor(session_computation, binary_op_request.rhs(),
+                            num_parameters, visited, is_functional);
       break;
     }
 
@@ -1817,8 +1839,8 @@ void ConstantVisitor(const SessionComputation& session_computation,
 
 }  // namespace
 
-StatusOr<bool> UserComputation::IsConstant(
-    const ComputationDataHandle& handle) {
+StatusOr<bool> UserComputation::IsConstant(const ComputationDataHandle& handle,
+                                           int64 num_parameters) {
   tensorflow::mutex_lock lock(mutex_);
 
   // Verify that the handle is valid.
@@ -1829,7 +1851,8 @@ StatusOr<bool> UserComputation::IsConstant(
 
   bool is_constant = true;
   std::set<int64> visited;
-  ConstantVisitor(session_computation_, handle, &visited, &is_constant);
+  PureFunctionalVisitor(session_computation_, handle, num_parameters, &visited,
+                        &is_constant);
 
   return is_constant;
 }
diff --git a/tensorflow/compiler/xla/service/user_computation.h b/tensorflow/compiler/xla/service/user_computation.h
index dabf68e298ed2600d5248b7b8c7b1e014efedb14..ac879ce55a75f6241a39f935b79017be46c1816b 100644
--- a/tensorflow/compiler/xla/service/user_computation.h
+++ b/tensorflow/compiler/xla/service/user_computation.h
@@ -250,9 +250,11 @@ class UserComputation {
   StatusOr<std::shared_ptr<const ProgramShape>> ComputeProgramShape(
       VersionedComputationHandle::Version version) const;
 
-  // Returns true if the given data handle does not depend on any
-  // parameters. That is, the value can be computed at compile time.
-  StatusOr<bool> IsConstant(const ComputationDataHandle& handle);
+  // Returns true if the given data handle does not depend on any parameter with
+  // index higher then num_parameters. That is, the value can be computed at
+  // compile time if we know the first num_parameters arguments.
+  StatusOr<bool> IsConstant(const ComputationDataHandle& handle,
+                            int64 num_parameters);
 
   // Returns the output shape of the operation indicated by the given handle.
   StatusOr<Shape> GetShape(const ComputationDataHandle& handle);
diff --git a/tensorflow/compiler/xla/tests/compute_constant_test.cc b/tensorflow/compiler/xla/tests/compute_constant_test.cc
index b2e9743af79d0e4658451e7a9522c338036851ba..d423c78476dde18d209b5efac9e8f77da41bfeb4 100644
--- a/tensorflow/compiler/xla/tests/compute_constant_test.cc
+++ b/tensorflow/compiler/xla/tests/compute_constant_test.cc
@@ -71,24 +71,27 @@ class ComputeConstantTest : public ::testing::Test {
 
   StatusOr<std::unique_ptr<Literal>> ComputeConstantLiteral(
       Client* client, const ComputationDataHandle& operand,
-      ComputationBuilder* builder, Layout* output_layout = nullptr) {
-    TF_ASSIGN_OR_RETURN(auto computed,
-                        builder->ComputeConstant(operand, output_layout));
+      ComputationBuilder* builder, Layout* output_layout = nullptr,
+      tensorflow::gtl::ArraySlice<Literal> parameters = {}) {
+    TF_ASSIGN_OR_RETURN(auto computed, builder->ComputeConstant(
+                                           operand, output_layout, parameters));
     return std::move(computed);
   }
 
   template <class Scalar>
-  StatusOr<Scalar> ComputeConstantScalar(Client* client,
-                                         const ComputationDataHandle& operand,
-                                         ComputationBuilder* builder) {
-    TF_ASSIGN_OR_RETURN(auto literal,
-                        ComputeConstantLiteral(client, operand, builder));
+  StatusOr<Scalar> ComputeConstantScalar(
+      Client* client, const ComputationDataHandle& operand,
+      ComputationBuilder* builder,
+      tensorflow::gtl::ArraySlice<Literal> parameters = {}) {
+    TF_ASSIGN_OR_RETURN(
+        auto literal,
+        ComputeConstantLiteral(client, operand, builder, nullptr, parameters));
     return literal->Get<Scalar>({});
   }
 
   bool IsConstant(const ComputationDataHandle& operand,
-                  ComputationBuilder* builder) {
-    StatusOr<bool> result = builder->IsConstant(operand);
+                  ComputationBuilder* builder, int64 num_parameters = 0) {
+    StatusOr<bool> result = builder->IsConstant(operand, num_parameters);
     EXPECT_TRUE(result.ok()) << result.status();
     return result.ok() ? result.ValueOrDie() : false;
   }
@@ -138,7 +141,25 @@ TEST_F(ComputeConstantTest, ScalarRng) {
   }
 }
 
-TEST_F(ComputeConstantTest, DirectParam) {
+TEST_F(ComputeConstantTest, Param) {
+  for (ClientType client_type : client_types) {
+    Client* client = ClientOrDie(platform_, client_type);
+    ComputationBuilder b(client, TestName());
+    auto param = b.Parameter(0, ShapeUtil::MakeShape(F32, {}), "lhs");
+    auto computation = b.Add(param, b.ConstantR0<float>(1.5f));
+
+    std::vector<Literal> arguments;
+    arguments.emplace_back(*Literal::CreateR0(42.5f));
+    EXPECT_TRUE(IsConstant(computation, &b, arguments.size()));
+
+    auto value =
+        ComputeConstantScalar<float>(client, computation, &b, arguments);
+    ASSERT_TRUE(value.ok()) << value.status();
+    EXPECT_EQ(value.ValueOrDie(), 44.0f);
+  }
+}
+
+TEST_F(ComputeConstantTest, DirectParamMissing) {
   for (ClientType client_type : client_types) {
     Client* client = ClientOrDie(platform_, client_type);
     ComputationBuilder b(client, TestName());
@@ -152,7 +173,7 @@ TEST_F(ComputeConstantTest, DirectParam) {
   }
 }
 
-TEST_F(ComputeConstantTest, IndirectParam) {
+TEST_F(ComputeConstantTest, IndirectParamMissing) {
   for (ClientType client_type : client_types) {
     Client* client = ClientOrDie(platform_, client_type);
     ComputationBuilder b(client, TestName());
diff --git a/tensorflow/compiler/xla/tests/dynamic_ops_test.cc b/tensorflow/compiler/xla/tests/dynamic_ops_test.cc
index 19252f50f25eee42e4e492b7f0e2ec3960c62126..ab8047c7480f43ba1fd7ca3ad22448e0dd890089 100644
--- a/tensorflow/compiler/xla/tests/dynamic_ops_test.cc
+++ b/tensorflow/compiler/xla/tests/dynamic_ops_test.cc
@@ -250,9 +250,6 @@ class DynamicUpdateSliceTest : public ClientLibraryTestBase {
     // Slice at dimension boundaries.
     RunR1<IndexT, DataT>({0, 1, 2, 3, 4, 5, 6, 7}, {8, 9, 10}, {5},
                          {0, 1, 2, 3, 4, 8, 9, 10});
-    // Slice at dimension boundaries, but with sizes that cause indices to wrap.
-    RunR1<IndexT, DataT>({0, 1, 2, 3, 4, 5, 6, 7}, {8, 9, 10}, {6},
-                         {0, 1, 2, 3, 4, 5, 8, 9});
     // Zero-sized update.
     RunR1<IndexT, DataT>({0, 1, 2, 3, 4, 5, 6, 7}, {}, {2},
                          {0, 1, 2, 3, 4, 5, 6, 7});
@@ -269,9 +266,6 @@ class DynamicUpdateSliceTest : public ClientLibraryTestBase {
     // Slice at dimension boundaries.
     RunR2<IndexT, DataT>({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, {{10, 11}}, {2, 1},
                          {{1, 2, 3}, {4, 5, 6}, {7, 10, 11}});
-    // Slice at dimension boundaries, but with sizes that cause indices to wrap.
-    RunR2<IndexT, DataT>({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, {{10, 11}}, {2, 2},
-                         {{1, 2, 3}, {4, 5, 6}, {7, 8, 10}});
     // Zero-sized update.
     RunR2<IndexT, DataT>({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, {{}}, {2, 1},
                          {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}});
@@ -289,10 +283,20 @@ class DynamicUpdateSliceTest : public ClientLibraryTestBase {
     RunR3<IndexT, DataT>(
         {{{1, 2}, {3, 4}, {5, 6}}, {{7, 8}, {9, 10}, {11, 12}}}, {{{13}, {15}}},
         {1, 1, 1}, {{{1, 2}, {3, 4}, {5, 6}}, {{7, 8}, {9, 13}, {11, 15}}});
+  }
+
+  template <typename IndexT, typename DataT>
+  void TestWrap() {
     // Slice at dimension boundaries, but with sizes that cause indices to wrap.
+    RunR1<IndexT, DataT>({0, 1, 2, 3, 4, 5, 6, 7}, {8, 9, 10}, {6},
+                         {10, 1, 2, 3, 4, 5, 8, 9});
+    // R2 Shape: [3, 3]
+    RunR2<IndexT, DataT>({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, {{10, 11}}, {2, 2},
+                         {{1, 2, 3}, {4, 5, 6}, {11, 8, 10}});
+    // R3 Shape: [2, 3, 2]
     RunR3<IndexT, DataT>(
         {{{1, 2}, {3, 4}, {5, 6}}, {{7, 8}, {9, 10}, {11, 12}}}, {{{13}, {15}}},
-        {1, 2, 1}, {{{1, 2}, {3, 4}, {5, 6}}, {{7, 8}, {9, 10}, {11, 13}}});
+        {1, 2, 1}, {{{1, 2}, {3, 4}, {5, 6}}, {{7, 15}, {9, 10}, {11, 13}}});
   }
 
   template <typename IndexT, typename DataT>
@@ -425,6 +429,12 @@ XLA_TEST_F(DynamicUpdateSliceTest, Int64R3) { TestR3<int64, int64>(); }
 
 XLA_TEST_F(DynamicUpdateSliceTest, UInt64R3) { TestR3<uint64, uint64>(); }
 
+XLA_TEST_F(DynamicUpdateSliceTest, Int32Wrap) { TestWrap<int32, float>(); }
+
+XLA_TEST_F(DynamicUpdateSliceTest, Int64Wrap) { TestWrap<int64, int64>(); }
+
+XLA_TEST_F(DynamicUpdateSliceTest, UInt64Wrap) { TestWrap<uint64, uint64>(); }
+
 XLA_TEST_F(DynamicUpdateSliceTest, Int32R1Pred) {
   // Slice at dimension start.
   RunR1<int32, bool>({false, false, true, true, false, true, true, false},
@@ -497,19 +507,13 @@ XLA_TEST_F(DynamicUpdateSliceTest, R3ContiguousMultipleElements) {
   RunR3Contiguous(operand_shape, /*index=*/1, /*size=*/2);
 }
 
-// TODO(b/34128753) CPU and GPU failed on 2016-01-06.  Appears not to handle
-// wrapping as expected.
-XLA_TEST_F(DynamicUpdateSliceTest,
-           DISABLED_ON_CPU(DISABLED_ON_GPU(R3ContiguousMultipleWrapping))) {
+XLA_TEST_F(DynamicUpdateSliceTest, R3ContiguousMultipleWrapping) {
   // Multiple element, wrapping.
   std::vector<int32> operand_shape({4, 5, 2});
   RunR3Contiguous(operand_shape, /*index=*/3, /*size=*/2);
 }
 
-// TODO(b/34128753) CPU and GPU failed on 2016-01-06.  Appears not to handle
-// wrapping as expected.
-XLA_TEST_F(DynamicUpdateSliceTest,
-           DISABLED_ON_CPU(DISABLED_ON_GPU(R3ContiguousTooLarge))) {
+XLA_TEST_F(DynamicUpdateSliceTest, R3ContiguousTooLarge) {
   // Multiple element, update size larger than operand.
   std::vector<int32> operand_shape({4, 5, 2});
   RunR3Contiguous(operand_shape, /*index=*/5, /*size=*/2);
diff --git a/tensorflow/compiler/xla/tests/while_test.cc b/tensorflow/compiler/xla/tests/while_test.cc
index 71a1b0abee51ba2819daed23208b0da8d5107207..49f673f5f0bf9b844ab4030383784208b4e2c58a 100644
--- a/tensorflow/compiler/xla/tests/while_test.cc
+++ b/tensorflow/compiler/xla/tests/while_test.cc
@@ -357,6 +357,111 @@ TEST_F(WhileTest, WhileWithVectorResultIntoTuple) {
   ComputeAndCompareTuple(&builder, *expected, {}, ErrorSpec(0.0001));
 }
 
+// TODO(b/63003356): 11-06-2017: fails on all back-ends with incorrect result.
+TEST_F(WhileTest, DISABLED_WhileWithPermutationAndTupleResult) {
+  std::vector<Shape> shape_elements = {
+      ShapeUtil::MakeShape(S32, {}), ShapeUtil::MakeShape(F32, {3}),
+      ShapeUtil::MakeShape(F32, {3}), ShapeUtil::MakeShape(F32, {3})};
+  Shape result_shape = ShapeUtil::MakeTupleShape(shape_elements);
+
+  // Create a computation for the condition.
+  // Repeat for N iterations.
+  const int N = 2;
+  Computation condition;
+  {
+    ComputationBuilder builder(client_, "condition");
+    auto prev = builder.Parameter(0, result_shape, "prev");
+    auto iteration = builder.GetTupleElement(prev, 0);
+    builder.Gt(builder.ConstantR0<int32>(N), iteration);
+    condition = builder.Build().ConsumeValueOrDie();
+  }
+
+  // Create a computation for the body.
+  // Add 1 to the iteration variable and permute the weights.
+  Computation body;
+  {
+    ComputationBuilder builder(client_, "body");
+    auto prev = builder.Parameter(0, result_shape, "prev");
+    auto iteration = builder.GetTupleElement(prev, 0);
+    auto w1 = builder.GetTupleElement(prev, 1);
+    auto w2 = builder.GetTupleElement(prev, 2);
+    auto w3 = builder.GetTupleElement(prev, 3);
+    auto result = builder.Tuple(
+        {builder.Add(iteration, builder.ConstantR0<int32>(1)), w3, w1, w2});
+    body = builder.Build().ConsumeValueOrDie();
+  }
+
+  // Create a While node with computations for the condition and the body.
+  ComputationBuilder builder(client_, "while");
+  auto init = builder.Tuple(
+      {builder.ConstantR0<int32>(0), builder.ConstantR1<float>(3, 1.f),
+       builder.ConstantR1<float>(3, 2.f), builder.ConstantR1<float>(3, 3.f)});
+  auto result = builder.While(condition, body, init);
+  VLOG(2) << "result = "
+          << ShapeUtil::HumanString(
+                 *builder.GetShape(result).ConsumeValueOrDie());
+
+  auto expected_counter = Literal::CreateR0<int32>(N);
+  auto expected_w1 = Literal::CreateR1<float>({1.0f, 1.0f, 1.0f});
+  auto expected_w2 = Literal::CreateR1<float>({2.0f, 2.0f, 2.0f});
+  auto expected_w3 = Literal::CreateR1<float>({3.0f, 3.0f, 3.0f});
+  auto expected = Literal::MakeTuple({expected_counter.get(), expected_w2.get(),
+                                      expected_w3.get(), expected_w1.get()});
+  VLOG(2) << "expected = " << ShapeUtil::HumanString(expected->shape());
+  ComputeAndCompareTuple(&builder, *expected, {}, ErrorSpec(0.0001));
+}
+
+// TODO(b/63003356): 11-06-2017: fails on all back-ends with incorrect result.
+TEST_F(WhileTest, DISABLED_WhileWithPermutationAndVectorResult) {
+  std::vector<Shape> shape_elements = {
+      ShapeUtil::MakeShape(S32, {}), ShapeUtil::MakeShape(F32, {3}),
+      ShapeUtil::MakeShape(F32, {3}), ShapeUtil::MakeShape(F32, {3})};
+  Shape result_shape = ShapeUtil::MakeTupleShape(shape_elements);
+
+  // Create a computation for the condition.
+  // Repeat for N iterations.
+  const int N = 2;
+  Computation condition;
+  {
+    ComputationBuilder builder(client_, "condition");
+    auto prev = builder.Parameter(0, result_shape, "prev");
+    auto iteration = builder.GetTupleElement(prev, 0);
+    builder.Gt(builder.ConstantR0<int32>(N), iteration);
+    condition = builder.Build().ConsumeValueOrDie();
+  }
+
+  // Create a computation for the body.
+  // Add 1 to the iteration variable permute the weights.
+  Computation body;
+  {
+    ComputationBuilder builder(client_, "body");
+    auto prev = builder.Parameter(0, result_shape, "prev");
+    auto iteration = builder.GetTupleElement(prev, 0);
+    auto w1 = builder.GetTupleElement(prev, 1);
+    auto w2 = builder.GetTupleElement(prev, 2);
+    auto w3 = builder.GetTupleElement(prev, 3);
+    auto result = builder.Tuple(
+        {builder.Add(iteration, builder.ConstantR0<int32>(1)), w3, w1, w2});
+    body = builder.Build().ConsumeValueOrDie();
+  }
+
+  // Create a While node with computations for the condition and the body.
+  ComputationBuilder builder(client_, "while");
+  auto init = builder.Tuple(
+      {builder.ConstantR0<int32>(0), builder.ConstantR1<float>(3, 1.f),
+       builder.ConstantR1<float>(3, 2.f), builder.ConstantR1<float>(3, 3.f)});
+  auto xla_while = builder.While(condition, body, init);
+
+  auto add12 = builder.Add(builder.GetTupleElement(xla_while, 1),
+                           builder.GetTupleElement(xla_while, 2));
+  auto result = builder.Add(add12, builder.GetTupleElement(xla_while, 3));
+  VLOG(2) << "result = "
+          << ShapeUtil::HumanString(
+                 *builder.GetShape(result).ConsumeValueOrDie());
+  std::vector<float> expected = {6.f, 6.f, 6.f};
+  ComputeAndCompareR1<float>(&builder, expected, {}, ErrorSpec(0.0001));
+}
+
 // Tests a while node when the result type T is a Tuple.
 //
 // tuple<int32, vector<float>> result(0, vector<float>(10, 0.0f));
@@ -899,6 +1004,51 @@ TEST_F(WhileTest, WhileThatTurnsScalarParameterToTupleElement) {
                              ErrorSpec(1e-6));
 }
 
+// Tests loop where the init value comes from two sources (constant and
+// parameter).
+//
+// int32 result = (0, 1);
+// while (result[0] + result[1] < 30) {
+//   result[0] = result[0] + 1;
+//   result[1] = result[1] + 1;
+// }
+TEST_F(WhileTest, WhileWithMixedTupleElements) {
+  auto result_shape = ShapeUtil::MakeTupleShape(
+      {ShapeUtil::MakeShape(S32, {}), ShapeUtil::MakeShape(S32, {})});
+
+  ComputationBuilder outer(client_, "outer");
+  auto p =
+      outer.Tuple({outer.ConstantR0<int32>(0),
+                   outer.Parameter(0, ShapeUtil::MakeShape(S32, {}), "t")});
+
+  ComputationBuilder cond(client_, "cond");
+  auto params = cond.Parameter(0, result_shape, "prev");
+  auto cond_t = cond.Add(cond.GetTupleElement(params, 1),
+                         cond.GetTupleElement(params, 0));
+  cond.Lt(cond_t, cond.ConstantR0<int32>(30));
+
+  ComputationBuilder body(client_, "body");
+  auto body_t = body.Parameter(0, result_shape, "t");
+
+  auto tuple = body.Tuple(
+      {body.Add(body.GetTupleElement(params, 0), body.ConstantR0<int32>(1)),
+       body.Add(body.GetTupleElement(params, 1), body.ConstantR0<int32>(1))});
+
+  TF_ASSERT_OK_AND_ASSIGN(auto cond_computation, cond.Build());
+  TF_ASSERT_OK_AND_ASSIGN(auto body_computation, body.Build());
+  outer.While(cond_computation, body_computation, p);
+
+  TF_ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<GlobalData> parameter_data,
+      client_->TransferToServer(*Literal::CreateR0<int32>(1)));
+
+  auto add1 = Literal::CreateR0<int32>(15);
+  auto add2 = Literal::CreateR0<int32>(16);
+  auto expected = Literal::MakeTuple({add1.get(), add2.get()});
+  ComputeAndCompareTuple(&outer, *expected, {parameter_data.get()},
+                         ErrorSpec(1e-6));
+}
+
 // Tests nested while loops.
 //
 // int32 result = 0;
diff --git a/tensorflow/compiler/xla/tools/parser/hlo_parser.cc b/tensorflow/compiler/xla/tools/parser/hlo_parser.cc
index 5de73ee866388e6b5b1a330b282792d1da4100c2..6c2e37e3b5cdd73157279fb171d3332aa9854184 100644
--- a/tensorflow/compiler/xla/tools/parser/hlo_parser.cc
+++ b/tensorflow/compiler/xla/tools/parser/hlo_parser.cc
@@ -58,6 +58,7 @@ class HloParser {
                             string* root_name);
   bool ParseInstruction(HloComputation::Builder* builder, string* root_name);
   bool ParseSharding(HloInstruction* instruction);
+  bool ParseControlPredecessors(HloInstruction* instruction);
   bool ParseLiteral(std::unique_ptr<Literal>* literal, const Shape& shape);
   bool ParseTupleLiteral(std::unique_ptr<Literal>* literal, const Shape& shape);
   bool ParseNonTupleLiteral(std::unique_ptr<Literal>* literal,
@@ -436,10 +437,35 @@ bool HloParser::ParseInstruction(HloComputation::Builder* builder,
       return TokenError(StrCat("parsing not yet implemented for op: ",
                                HloOpcodeString(opcode)));
   }
-  // Parse "sharding=".
-  if (lexer_.GetKind() == TokKind::kComma) {
-    if (!ParseSharding(instruction)) {
-      return false;
+
+  bool has_sharding = false;
+  bool has_control = false;
+  while (EatIfPresent(TokKind::kComma)) {
+    string attribute_name;
+    if (!ParseAttributeName(&attribute_name)) {
+      return TokenError("expects ', sharding=' or ', control-predecessors='");
+    }
+
+    if (attribute_name == "sharding") {
+      // Parse "sharding=".
+      if (has_sharding) {
+        return TokenError("expects at most 1 'sharding='");
+      }
+      has_sharding = true;
+      if (!ParseSharding(instruction)) {
+        return false;
+      }
+    } else if (attribute_name == "control-predecessors") {
+      // Parse "control-predecessors"
+      if (has_control) {
+        return TokenError("expects at most 1 'control-predecessors='");
+      }
+      has_control = true;
+      if (!ParseControlPredecessors(instruction)) {
+        return false;
+      }
+    } else {
+      return TokenError(StrCat("unexpected attribute: ", attribute_name));
     }
   }
 
@@ -449,15 +475,6 @@ bool HloParser::ParseInstruction(HloComputation::Builder* builder,
 // ::= '{' 'replicated'? 'maximal'? ('device=' int)? shape? ('devices=' ('['
 // dims ']')* device_list)? '}' dims ::= int_list device_list ::= int_list
 bool HloParser::ParseSharding(HloInstruction* instruction) {
-  if (!ParseToken(TokKind::kComma,
-                  "expects ',' in front of an extra attribute")) {
-    return false;
-  }
-  string attribute_name;
-  if (!ParseAttributeName(&attribute_name) || attribute_name != "sharding") {
-    return TokenError("expects attribute name: sharding");
-  }
-
   if (!ParseToken(TokKind::kLbrace,
                   "expected '{' to start sharding attribute")) {
     return false;
@@ -577,6 +594,34 @@ bool HloParser::ParseSharding(HloInstruction* instruction) {
   return true;
 }
 
+// '{' name+ '}'
+bool HloParser::ParseControlPredecessors(HloInstruction* instruction) {
+  if (!ParseToken(TokKind::kLbrace,
+                  "expects '{' at the beginning of control predecessors")) {
+    return false;
+  }
+  do {
+    string name;
+    if (!ParseName(&name)) {
+      return TokenError("expects a control predecessor");
+    }
+    HloInstruction* pre =
+        tensorflow::gtl::FindPtrOrNull(instruction_pool_, name);
+    if (!pre) {
+      return TokenError(
+          StrCat("control predecessor ", name, " is not defined: "));
+    }
+    Status status = pre->AddControlDependencyTo(instruction);
+    if (!status.ok()) {
+      return TokenError(StrCat("error adding control dependency for: ", name,
+                               " status: ", status.ToString()));
+    }
+  } while (EatIfPresent(TokKind::kComma));
+
+  return ParseToken(TokKind::kRbrace,
+                    "expects '}' at the end of control predecessors");
+}
+
 bool HloParser::SetValueInLiteral(int64 value, int64 linear_index,
                                   Literal* literal) {
   const Shape& shape = literal->shape();
diff --git a/tensorflow/compiler/xla/tools/parser/hlo_parser_test.cc b/tensorflow/compiler/xla/tools/parser/hlo_parser_test.cc
index e065af7da61fb6096c820825cbd81d4a788c93fe..359256f0646367f8af13439b30067624defcd44c 100644
--- a/tensorflow/compiler/xla/tools/parser/hlo_parser_test.cc
+++ b/tensorflow/compiler/xla/tools/parser/hlo_parser_test.cc
@@ -214,7 +214,7 @@ R"(HloModule TwoSendRecvBothWayRecvFist_module:
 ENTRY %TwoSendRecvBothWayRecvFist.v3 () -> f32[] {
   %recv = f32[] recv(), channel_id=15, sharding={maximal device=1}
   ROOT %constant = f32[] constant(2.1), sharding={maximal device=0}
-  %send = () send(f32[] %constant), channel_id=16, sharding={maximal device=0}
+  %send = () send(f32[] %constant), channel_id=16, sharding={maximal device=0}, control-predecessors={%recv}
 }
 
 )"
diff --git a/tensorflow/compiler/xla/xla.proto b/tensorflow/compiler/xla/xla.proto
index ce3c3eee68ad7f7ebb42836e3cae14803f8650d7..710bb6ff25bf649693165c5e9fb6bc50e81db4ca 100644
--- a/tensorflow/compiler/xla/xla.proto
+++ b/tensorflow/compiler/xla/xla.proto
@@ -361,6 +361,7 @@ message WaitForExecutionResponse {
 message IsConstantRequest {
   ComputationHandle computation = 1;
   ComputationDataHandle operand = 2;
+  int64 num_parameters = 3;
 }
 
 message IsConstantResponse {
@@ -371,6 +372,7 @@ message ComputeConstantRequest {
   ComputationHandle computation = 1;
   ComputationDataHandle operand = 2;
   Layout output_layout = 3;
+  repeated LiteralProto parameters = 4;
 }
 
 message ComputeConstantResponse {
diff --git a/tensorflow/contrib/batching/BUILD b/tensorflow/contrib/batching/BUILD
index 8b7df4a84c558f662405a28a42426583d5ab39cd..a111cfecb366fe245150cc71d2c43662d0d69090 100644
--- a/tensorflow/contrib/batching/BUILD
+++ b/tensorflow/contrib/batching/BUILD
@@ -82,6 +82,7 @@ cc_library(
 tf_cc_test(
     name = "adaptive_shared_batch_scheduler_test",
     srcs = ["adaptive_shared_batch_scheduler_test.cc"],
+    tags = ["manual"],  # b/69013768
     deps = [
         ":adaptive_shared_batch_scheduler",
         "//tensorflow/contrib/batching/test_util:fake_clock_env",
diff --git a/tensorflow/contrib/batching/adaptive_shared_batch_scheduler.h b/tensorflow/contrib/batching/adaptive_shared_batch_scheduler.h
index a0606427a526ffc67e10d12a084eabc64564e4ab..6ed177e001758ad8c566c7965e1ec10ae5235fc8 100644
--- a/tensorflow/contrib/batching/adaptive_shared_batch_scheduler.h
+++ b/tensorflow/contrib/batching/adaptive_shared_batch_scheduler.h
@@ -399,7 +399,7 @@ ASBSQueue<TaskType>::~ASBSQueue() {
 
 template <typename TaskType>
 Status ASBSQueue<TaskType>::Schedule(std::unique_ptr<TaskType>* task) {
-  bool added_new_batch = false;
+  ASBSBatch<TaskType>* new_batch = nullptr;
   size_t size = (*task)->size();
   if (size > options_.max_batch_size) {
     return errors::InvalidArgument("Task size ", size,
@@ -418,15 +418,14 @@ Status ASBSQueue<TaskType>::Schedule(std::unique_ptr<TaskType>* task) {
       current_batch_ = nullptr;
     }
     if (!current_batch_) {
-      added_new_batch = true;
       num_enqueued_batches_++;
-      current_batch_ =
+      current_batch_ = new_batch =
           new ASBSBatch<TaskType>(this, scheduler_->GetEnv()->NowMicros());
     }
     current_batch_->AddTask(std::move(*task));
     num_enqueued_tasks_++;
   }
-  if (added_new_batch) scheduler_->AddBatch(current_batch_);
+  if (new_batch != nullptr) scheduler_->AddBatch(new_batch);
   return Status::OK();
 }
 
diff --git a/tensorflow/contrib/boosted_trees/python/training/functions/gbdt_batch.py b/tensorflow/contrib/boosted_trees/python/training/functions/gbdt_batch.py
index 4d9fd753233f520b961559e2dc3adbafc5bb1d2f..cebe3474ca9251971c23bde9e82564189c1ee624 100644
--- a/tensorflow/contrib/boosted_trees/python/training/functions/gbdt_batch.py
+++ b/tensorflow/contrib/boosted_trees/python/training/functions/gbdt_batch.py
@@ -208,7 +208,7 @@ def extract_features(features, feature_columns):
       if tensor.dtype == dtypes.float32:
         if len(tensor.shape) > 1 and tensor.shape[1] > 1:
           unstacked = array_ops.unstack(tensor, axis=1)
-          for i in xrange(len(unstacked)):
+          for i in range(len(unstacked)):
             dense_float_names.append(_FEATURE_NAME_TEMPLATE % (key, i))
             dense_floats.append(array_ops.reshape(unstacked[i], [-1, 1]))
         else:
diff --git a/tensorflow/contrib/cmake/external/farmhash.cmake b/tensorflow/contrib/cmake/external/farmhash.cmake
index 96fade8b53273afdc379c7c13017e4917ee534f3..0cd0c1030c73d5218411f281d2b077af217e8275 100644
--- a/tensorflow/contrib/cmake/external/farmhash.cmake
+++ b/tensorflow/contrib/cmake/external/farmhash.cmake
@@ -15,8 +15,8 @@
 include (ExternalProject)
 
 set(farmhash_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/external/farmhash_archive ${CMAKE_CURRENT_BINARY_DIR}/external/farmhash_archive/util)
-set(farmhash_URL https://github.com/google/farmhash/archive/34c13ddfab0e35422f4c3979f360635a8c050260.zip)
-set(farmhash_HASH SHA256=e3d37a59101f38fd58fb799ed404d630f0eee18bfc2a2433910977cc8fea9c28)
+set(farmhash_URL https://mirror.bazel.build/github.com/google/farmhash/archive/816a4ae622e964763ca0862d9dbd19324a1eaf45.tar.gz)
+set(farmhash_HASH SHA256=6560547c63e4af82b0f202cb710ceabb3f21347a4b996db565a411da5b17aba0)
 set(farmhash_BUILD ${CMAKE_CURRENT_BINARY_DIR}/farmhash/src/farmhash)
 set(farmhash_INSTALL ${CMAKE_CURRENT_BINARY_DIR}/farmhash/install)
 set(farmhash_INCLUDES ${farmhash_BUILD})
diff --git a/tensorflow/contrib/cmake/external/fft2d.cmake b/tensorflow/contrib/cmake/external/fft2d.cmake
index a35c24e9e01101f837ba961c06429c981ddc4648..d3af2a46761c0f7f0b5db134af8400fc93f2f095 100644
--- a/tensorflow/contrib/cmake/external/fft2d.cmake
+++ b/tensorflow/contrib/cmake/external/fft2d.cmake
@@ -15,7 +15,7 @@
 
 include (ExternalProject)
 
-set(fft2d_URL http://www.kurims.kyoto-u.ac.jp/~ooura/fft.tgz)
+set(fft2d_URL https://mirror.bazel.build/www.kurims.kyoto-u.ac.jp/~ooura/fft.tgz)
 set(fft2d_HASH SHA256=52bb637c70b971958ec79c9c8752b1df5ff0218a4db4510e60826e0cb79b5296)
 set(fft2d_BUILD ${CMAKE_CURRENT_BINARY_DIR}/fft2d/)
 set(fft2d_INSTALL ${CMAKE_CURRENT_BINARY_DIR}/fft2d/src)
diff --git a/tensorflow/contrib/cmake/external/gemmlowp.cmake b/tensorflow/contrib/cmake/external/gemmlowp.cmake
index 54a9e96ce58c5501217368b0d12089aa14696b71..3b146657bfc9bdd54db14839195af45972e67aff 100644
--- a/tensorflow/contrib/cmake/external/gemmlowp.cmake
+++ b/tensorflow/contrib/cmake/external/gemmlowp.cmake
@@ -14,8 +14,8 @@
 # ==============================================================================
 include (ExternalProject)
 
-set(gemmlowp_URL http://github.com/google/gemmlowp/archive/010bb3e71a26ca1d0884a167081d092b43563996.tar.gz)
-set(gemmlowp_HASH SHA256=861cc6d9d902861f54fd77e1ab79286477dcc559b2a283e75b9c22d37b61f6ae)
+set(gemmlowp_URL https://mirror.bazel.build/github.com/google/gemmlowp/archive/010bb3e71a26ca1d0884a167081d092b43563996.zip)
+set(gemmlowp_HASH SHA256=dd2557072bde12141419cb8320a9c25e6ec41a8ae53c2ac78c076a347bb46d9d)
 set(gemmlowp_BUILD ${CMAKE_CURRENT_BINARY_DIR}/gemmlowp/src/gemmlowp)
 set(gemmlowp_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/gemmlowp/src/gemmlowp)
 
diff --git a/tensorflow/contrib/cmake/external/jemalloc.cmake b/tensorflow/contrib/cmake/external/jemalloc.cmake
index e4737a1dd825409133cdfd8a54f20dac819c0d5b..198ba13e64e4b6df57c4325a0104b1a6745d173a 100644
--- a/tensorflow/contrib/cmake/external/jemalloc.cmake
+++ b/tensorflow/contrib/cmake/external/jemalloc.cmake
@@ -15,7 +15,7 @@
 include (ExternalProject)
 
 set(jemalloc_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}/jemalloc/src/jemalloc/include)
-set(jemalloc_URL https://github.com/jemalloc/jemalloc-cmake/archive/jemalloc-cmake.4.3.1.tar.gz)
+set(jemalloc_URL https://mirror.bazel.build/github.com/jemalloc/jemalloc-cmake/archive/jemalloc-cmake.4.3.1.tar.gz)
 set(jemalloc_HASH SHA256=f9be9a05fe906deb5c1c8ca818071a7d2e27d66fd87f5ba9a7bf3750bcedeaf0)
 set(jemalloc_BUILD ${CMAKE_CURRENT_BINARY_DIR}/jemalloc/src/jemalloc)
 
diff --git a/tensorflow/contrib/cmake/external/sqlite.cmake b/tensorflow/contrib/cmake/external/sqlite.cmake
index 6d06193824b32557c1d2195c940ff9c698be1bdf..785039a46983747557607562675349c150e064ad 100644
--- a/tensorflow/contrib/cmake/external/sqlite.cmake
+++ b/tensorflow/contrib/cmake/external/sqlite.cmake
@@ -15,7 +15,7 @@
 include (ExternalProject)
 
 set(sqlite_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/external/sqlite)
-set(sqlite_URL http://www.sqlite.org/2017/sqlite-amalgamation-3200000.zip)
+set(sqlite_URL https://mirror.bazel.build/www.sqlite.org/2017/sqlite-amalgamation-3200000.zip)
 set(sqlite_HASH SHA256=208780b3616f9de0aeb50822b7a8f5482f6515193859e91ed61637be6ad74fd4)
 set(sqlite_BUILD ${CMAKE_CURRENT_BINARY_DIR}/sqlite/src/sqlite)
 set(sqlite_INSTALL ${CMAKE_CURRENT_BINARY_DIR}/sqlite/install)
diff --git a/tensorflow/contrib/cmake/tf_core_kernels.cmake b/tensorflow/contrib/cmake/tf_core_kernels.cmake
index f978c8ccd5a454ca4a89de0ab5d757b566295c60..5b62598aa58fb2ce37694055fc576a6fc308dc3e 100644
--- a/tensorflow/contrib/cmake/tf_core_kernels.cmake
+++ b/tensorflow/contrib/cmake/tf_core_kernels.cmake
@@ -70,6 +70,7 @@ if(tensorflow_BUILD_CONTRIB_KERNELS)
       "${tensorflow_source_dir}/tensorflow/contrib/cudnn_rnn/kernels/cudnn_rnn_ops.cc"
       "${tensorflow_source_dir}/tensorflow/contrib/cudnn_rnn/ops/cudnn_rnn_ops.cc"
       "${tensorflow_source_dir}/tensorflow/contrib/data/kernels/prefetching_kernels.cc"
+      "${tensorflow_source_dir}/tensorflow/contrib/data/ops/dataset_ops.cc"
       "${tensorflow_source_dir}/tensorflow/contrib/data/ops/prefetching_ops.cc"
       "${tensorflow_source_dir}/tensorflow/contrib/factorization/kernels/clustering_ops.cc"
       "${tensorflow_source_dir}/tensorflow/contrib/factorization/kernels/masked_matmul_ops.cc"
diff --git a/tensorflow/contrib/cmake/tf_core_ops.cmake b/tensorflow/contrib/cmake/tf_core_ops.cmake
index 4a61ed7a3548b1992ddc71acb8a7761e252296ea..03c168795cc2455327f0b7bbf40fd1fd1eebb34e 100644
--- a/tensorflow/contrib/cmake/tf_core_ops.cmake
+++ b/tensorflow/contrib/cmake/tf_core_ops.cmake
@@ -81,6 +81,7 @@ GENERATE_CONTRIB_OP_LIBRARY(boosted_trees_prediction "${tensorflow_source_dir}/t
 GENERATE_CONTRIB_OP_LIBRARY(boosted_trees_quantiles "${tensorflow_source_dir}/tensorflow/contrib/boosted_trees/ops/quantile_ops.cc")
 GENERATE_CONTRIB_OP_LIBRARY(boosted_trees_stats_accumulator "${tensorflow_source_dir}/tensorflow/contrib/boosted_trees/ops/stats_accumulator_ops.cc")
 GENERATE_CONTRIB_OP_LIBRARY(cudnn_rnn "${tensorflow_source_dir}/tensorflow/contrib/cudnn_rnn/ops/cudnn_rnn_ops.cc")
+GENERATE_CONTRIB_OP_LIBRARY(data_dataset "${tensorflow_source_dir}/tensorflow/contrib/data/ops/dataset_ops.cc")
 GENERATE_CONTRIB_OP_LIBRARY(data_prefetching "${tensorflow_source_dir}/tensorflow/contrib/data/ops/prefetching_ops.cc")
 GENERATE_CONTRIB_OP_LIBRARY(factorization_clustering "${tensorflow_source_dir}/tensorflow/contrib/factorization/ops/clustering_ops.cc")
 GENERATE_CONTRIB_OP_LIBRARY(factorization_factorization "${tensorflow_source_dir}/tensorflow/contrib/factorization/ops/factorization_ops.cc")
diff --git a/tensorflow/contrib/cmake/tf_python.cmake b/tensorflow/contrib/cmake/tf_python.cmake
index 68234911a3fda9df6c65f32b088d0968a6f37c00..61900450475e9d5734789c5be97f8a7fc636bebc 100755
--- a/tensorflow/contrib/cmake/tf_python.cmake
+++ b/tensorflow/contrib/cmake/tf_python.cmake
@@ -224,6 +224,7 @@ add_python_module("tensorflow/python/grappler")
 add_python_module("tensorflow/python/keras")
 add_python_module("tensorflow/python/keras/activations")
 add_python_module("tensorflow/python/keras/applications")
+add_python_module("tensorflow/python/keras/applications/inception_resnet_v2")
 add_python_module("tensorflow/python/keras/applications/inception_v3")
 add_python_module("tensorflow/python/keras/applications/mobilenet")
 add_python_module("tensorflow/python/keras/applications/resnet50")
@@ -776,6 +777,8 @@ GENERATE_PYTHON_OP_LIB("contrib_boosted_trees_stats_accumulator_ops"
   DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/tf_python/tensorflow/contrib/boosted_trees/python/ops/gen_stats_accumulator_ops.py)
 GENERATE_PYTHON_OP_LIB("contrib_cudnn_rnn_ops"
   DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/tf_python/tensorflow/contrib/cudnn_rnn/ops/gen_cudnn_rnn_ops.py)
+GENERATE_PYTHON_OP_LIB("contrib_data_dataset_ops"
+  DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/tf_python/tensorflow/contrib/data/python/ops/gen_dataset_ops.py)
 GENERATE_PYTHON_OP_LIB("contrib_data_prefetching_ops"
   DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/tf_python/tensorflow/contrib/data/python/ops/gen_prefetching_ops.py)
 GENERATE_PYTHON_OP_LIB("contrib_factorization_clustering_ops"
diff --git a/tensorflow/contrib/crf/python/ops/crf.py b/tensorflow/contrib/crf/python/ops/crf.py
index 7166e38b28365a6dbce9cf134f81b08a57c722de..c8adb0369b98947d2d29374ee8ada1185815d3cd 100644
--- a/tensorflow/contrib/crf/python/ops/crf.py
+++ b/tensorflow/contrib/crf/python/ops/crf.py
@@ -360,8 +360,8 @@ class CrfDecodeForwardRnnCell(rnn_cell.RNNCell):
       scope: Unused variable scope of this cell.
 
     Returns:
-      backpointers: [batch_size, num_tags], containing backpointers.
-      new_state: [batch_size, num_tags], containing new score values.
+      backpointers: A [batch_size, num_tags] matrix of backpointers.
+      new_state: A [batch_size, num_tags] matrix of new score values.
     """
     # For simplicity, in shape comments, denote:
     # 'batch_size' by 'B', 'max_seq_len' by 'T' , 'num_tags' by 'O' (output).
@@ -385,7 +385,7 @@ class CrfDecodeBackwardRnnCell(rnn_cell.RNNCell):
     """Initialize the CrfDecodeBackwardRnnCell.
 
     Args:
-      num_tags
+      num_tags: An integer.
     """
     self._num_tags = num_tags
 
@@ -401,8 +401,9 @@ class CrfDecodeBackwardRnnCell(rnn_cell.RNNCell):
     """Build the CrfDecodeBackwardRnnCell.
 
     Args:
-      inputs: [batch_size, num_tags], backpointer of next step (in time order).
-      state: [batch_size, 1], next position's tag index.
+      inputs: A [batch_size, num_tags] matrix of
+            backpointer of next step (in time order).
+      state: A [batch_size, 1] matrix of tag index of next step.
       scope: Unused variable scope of this cell.
 
     Returns:
@@ -426,16 +427,16 @@ def crf_decode(potentials, transition_params, sequence_length):
   This is a function for tensor.
 
   Args:
-    potentials: A [batch_size, max_seq_len, num_tags] tensor, matrix of
+    potentials: A [batch_size, max_seq_len, num_tags] tensor of
               unary potentials.
-    transition_params: A [num_tags, num_tags] tensor, matrix of
+    transition_params: A [num_tags, num_tags] matrix of
               binary potentials.
-    sequence_length: A [batch_size] tensor, containing sequence lengths.
+    sequence_length: A [batch_size] vector of true sequence lengths.
 
   Returns:
-    decode_tags: A [batch_size, max_seq_len] tensor, with dtype tf.int32.
+    decode_tags: A [batch_size, max_seq_len] matrix, with dtype `tf.int32`.
                 Contains the highest scoring tag indicies.
-    best_score: A [batch_size] tensor, containing the score of decode_tags.
+    best_score: A [batch_size] vector, containing the score of `decode_tags`.
   """
   # For simplicity, in shape comments, denote:
   # 'batch_size' by 'B', 'max_seq_len' by 'T' , 'num_tags' by 'O' (output).
diff --git a/tensorflow/contrib/data/BUILD b/tensorflow/contrib/data/BUILD
index eaede0e00ecf1986873d50709d135d3f4b3ac9cd..7bcf5a5f4dcd6293644725a2ccf78a763da3d9eb 100644
--- a/tensorflow/contrib/data/BUILD
+++ b/tensorflow/contrib/data/BUILD
@@ -35,8 +35,19 @@ tf_custom_op_library(
     ],
 )
 
+# TODO(mrry): Move the kernels out of the core library into this library.
+tf_custom_op_library(
+    name = "_dataset_ops.so",
+    srcs = [
+        "ops/dataset_ops.cc",
+    ],
+)
+
 tf_gen_op_libs(
-    op_lib_names = ["prefetching_ops"],
+    op_lib_names = [
+        "dataset_ops",
+        "prefetching_ops",
+    ],
 )
 
 filegroup(
diff --git a/tensorflow/contrib/data/__init__.py b/tensorflow/contrib/data/__init__.py
index 6c46acf20442c2cc435829afa57e8383b493d6af..0c7e793689204ba18dcab03c87902103e5802e45 100644
--- a/tensorflow/contrib/data/__init__.py
+++ b/tensorflow/contrib/data/__init__.py
@@ -30,6 +30,7 @@ See the @{$datasets$Importing Data} Programmer's Guide for an overview.
 @@make_saveable_from_iterator
 @@read_batch_features
 @@unbatch
+@@parallel_interleave
 @@rejection_resample
 @@sloppy_interleave
 
@@ -40,8 +41,8 @@ from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
-# pylint: disable=unused-import
 
+# pylint: disable=unused-import
 from tensorflow.contrib.data.python.ops.batching import batch_and_drop_remainder
 from tensorflow.contrib.data.python.ops.batching import dense_to_sparse_batch
 from tensorflow.contrib.data.python.ops.batching import unbatch
@@ -50,6 +51,7 @@ from tensorflow.contrib.data.python.ops.dataset_ops import get_single_element
 from tensorflow.contrib.data.python.ops.enumerate_ops import enumerate_dataset
 from tensorflow.contrib.data.python.ops.error_ops import ignore_errors
 from tensorflow.contrib.data.python.ops.grouping import group_by_window
+from tensorflow.contrib.data.python.ops.interleave_ops import parallel_interleave
 from tensorflow.contrib.data.python.ops.interleave_ops import sloppy_interleave
 from tensorflow.contrib.data.python.ops.iterator_ops import make_saveable_from_iterator
 from tensorflow.contrib.data.python.ops.readers import FixedLengthRecordDataset
diff --git a/tensorflow/contrib/data/ops/dataset_ops.cc b/tensorflow/contrib/data/ops/dataset_ops.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1574384cb2bf5578bc5ccd13d2792e30b6359996
--- /dev/null
+++ b/tensorflow/contrib/data/ops/dataset_ops.cc
@@ -0,0 +1,232 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#include "tensorflow/core/framework/common_shape_fns.h"
+#include "tensorflow/core/framework/op.h"
+#include "tensorflow/core/framework/op_def_builder.h"
+#include "tensorflow/core/framework/shape_inference.h"
+
+namespace tensorflow {
+
+// --------------------------------------------------------------------------
+
+// The ops in this section can be composed to define an input
+// pipeline. Each op produces a DT_VARIANT tensor that represents
+// a DAG of "dataset" objects. An "dataset" object can be converted
+// to a stateful "iterator" by passing the "dataset" to the
+// "MakeIterator" op.
+//
+// TODO(b/65524810): DT_VARIANT tensors that represent "dataset" objects are
+// not presently serializable. To avoid issues with constant folding, ensure
+// that any "source dataset" ops (i.e. ops that output a dataset and do not
+// take one as input) are marked "stateful".
+
+REGISTER_OP("IgnoreErrorsDataset")
+    .Input("input_dataset: variant")
+    .Output("handle: variant")
+    .Attr("output_types: list(type) >= 1")
+    .Attr("output_shapes: list(shape) >= 1")
+    .SetShapeFn(shape_inference::ScalarShape)
+    .Doc(R"doc(
+Creates a dataset that contains the elements of `input_dataset` ignoring errors.
+)doc");
+
+REGISTER_OP("MapAndBatchDataset")
+    .Input("input_dataset: variant")
+    .Input("other_arguments: Targuments")
+    .Input("batch_size: int64")
+    .Input("num_parallel_batches: int64")
+    .Output("handle: variant")
+    .Attr("f: func")
+    .Attr("Targuments: list(type) >= 0")
+    .Attr("output_types: list(type) >= 1")
+    .Attr("output_shapes: list(shape) >= 1")
+    .SetShapeFn(shape_inference::ScalarShape)
+    .Doc(R"doc(
+Creates a dataset that applies `f` to the outputs of `input_dataset` and then
+batches `batch_size` of them.
+
+Unlike a "MapDataset", which applies `f` sequentially, this dataset invokes up
+to `batch_size * num_parallel_batches` copies of `f` in parallel.
+
+batch_size: A scalar representing the number of elements to accumulate in a
+  batch. It determines the number of concurrent invocations of `f` that process
+  elements from `input_dataset` in parallel.
+num_parallel_batches: A scalar representing the number of batches to create in
+  parallel. Processing multiple batches in parallel benefits workloads prone to
+  stragglers.
+)doc");
+
+REGISTER_OP("ScanDataset")
+    .Input("input_dataset: variant")
+    .Input("initial_state: Tstate")
+    .Input("other_arguments: Targuments")
+    .Output("handle: variant")
+    .Attr("f: func")
+    .Attr("Tstate: list(type) >= 1")
+    .Attr("Targuments: list(type) >= 0")
+    .Attr("output_types: list(type) >= 1")
+    .Attr("output_shapes: list(shape) >= 1")
+    .SetShapeFn(shape_inference::ScalarShape)
+    .Doc(R"doc(
+Creates a dataset successively reduces `f` over the elements of `input_dataset`.
+)doc");
+
+REGISTER_OP("ParallelInterleaveDataset")
+    .Input("input_dataset: variant")
+    .Input("other_arguments: Targuments")
+    .Input("cycle_length: int64")
+    .Input("block_length: int64")
+    .Input("sloppy: bool")
+    .Output("handle: variant")
+    .Attr("f: func")
+    .Attr("Targuments: list(type) >= 0")
+    .Attr("output_types: list(type) >= 1")
+    .Attr("output_shapes: list(shape) >= 1")
+    .SetShapeFn(shape_inference::ScalarShape)
+    .Doc(R"doc(
+Creates a dataset that applies `f` to the outputs of `input_dataset`.
+
+The resulting dataset is similar to the `InterleaveDataset`, with the exception
+that if retrieving the next value from a dataset would cause the requester to
+block, it will skip that input dataset. This dataset is especially useful
+when loading data from a variable-latency datastores (e.g. HDFS, GCS), as it
+allows the training step to proceed so long as some data is available.
+
+!! WARNING !! This dataset is not deterministic!
+
+f: A function mapping elements of `input_dataset`, concatenated with
+   `other_arguments`, to a Dataset variant that contains elements matching
+   `output_types` and `output_shapes`.
+)doc");
+
+REGISTER_OP("GroupByWindowDataset")
+    .Input("input_dataset: variant")
+    .Input("key_func_other_arguments: Tkey_func_other_arguments")
+    .Input("reduce_func_other_arguments: Treduce_func_other_arguments")
+    .Input(
+        "window_size_func_other_arguments: Twindow_size_func_other_arguments")
+    .Output("handle: variant")
+    .Attr("key_func: func")
+    .Attr("reduce_func: func")
+    .Attr("window_size_func: func")
+    .Attr("Tkey_func_other_arguments: list(type) >= 0")
+    .Attr("Treduce_func_other_arguments: list(type) >= 0")
+    .Attr("Twindow_size_func_other_arguments: list(type) >= 0")
+    .Attr("output_types: list(type) >= 1")
+    .Attr("output_shapes: list(shape) >= 1")
+    .SetShapeFn(shape_inference::ScalarShape)
+    .Doc(R"doc(
+Creates a dataset that computes a windowed group-by on `input_dataset`.
+
+// TODO(mrry): Support non-int64 keys.
+
+key_func: A function mapping an element of `input_dataset`, concatenated
+  with `key_func_other_arguments` to a scalar value of type DT_INT64.
+)doc");
+
+REGISTER_OP("DenseToSparseBatchDataset")
+    .Input("input_dataset: variant")
+    .Input("batch_size: int64")
+    .Input("row_shape: int64")
+    .Output("handle: variant")
+    // NOTE(mrry): the 0th and 2nd elements will be DT_INT64.
+    .Attr("output_types: list(type) >= 1")
+    // NOTE(mrry): the 1st and 2nd elements will be vectors.
+    .Attr("output_shapes: list(shape) >= 1")
+    .SetShapeFn(shape_inference::ScalarShape)
+    .Doc(R"doc(
+Creates a dataset that yields a SparseTensor for each element of the input.
+
+input_dataset: A handle to an input dataset. Must have a single component.
+batch_size: A scalar representing the number of elements to accumulate in a
+  batch.
+row_shape: A vector representing the dense shape of each row in the produced
+  SparseTensor. The shape may be partially specified, using `-1` to indicate
+  that a particular dimension should use the maximum size of all batch elements.
+)doc");
+
+REGISTER_OP("SqlDataset")
+    .Input("driver_name: string")
+    .Input("data_source_name: string")
+    .Input("query: string")
+    .Output("handle: variant")
+    .Attr("output_types: list(type) >= 1")
+    .Attr("output_shapes: list(shape) >= 1")
+    .SetIsStateful()  // TODO(b/65524810): Source dataset ops must be marked
+                      // stateful to inhibit constant folding.
+    .SetShapeFn(shape_inference::ScalarShape)
+    .Doc(R"doc(
+Creates a dataset that executes a SQL query and emits rows of the result set.
+
+driver_name: The database type. Currently, the only supported type is 'sqlite'.
+data_source_name: A connection string to connect to the database.
+query: A SQL query to execute.
+)doc");
+
+REGISTER_OP("DatasetToSingleElement")
+    .Input("dataset: variant")
+    .Output("components: output_types")
+    .Attr("output_types: list(type) >= 1")
+    .Attr("output_shapes: list(shape) >= 1")
+    .SetShapeFn([](shape_inference::InferenceContext* c) {
+      shape_inference::ShapeHandle unused;
+      TF_RETURN_IF_ERROR(c->WithRank(c->input(0), 0, &unused));
+      std::vector<PartialTensorShape> output_shapes;
+      TF_RETURN_IF_ERROR(c->GetAttr("output_shapes", &output_shapes));
+      if (output_shapes.size() != c->num_outputs()) {
+        return errors::InvalidArgument(
+            "`output_shapes` must be the same length as `output_types` (",
+            output_shapes.size(), " vs. ", c->num_outputs());
+      }
+      for (size_t i = 0; i < output_shapes.size(); ++i) {
+        shape_inference::ShapeHandle output_shape_handle;
+        TF_RETURN_IF_ERROR(c->MakeShapeFromPartialTensorShape(
+            output_shapes[i], &output_shape_handle));
+        c->set_output(static_cast<int>(i), output_shape_handle);
+      }
+      return Status::OK();
+    })
+    .Doc(R"doc(
+Outputs the single element from the given dataset.
+
+dataset: A handle to a dataset that contains a single element.
+components: The components of the single element of `input`.
+)doc");
+
+REGISTER_OP("SerializeIterator")
+    .Input("resource_handle: resource")
+    .Output("serialized: variant")
+    .SetShapeFn(shape_inference::ScalarShape)
+    .Doc(R"doc(
+Converts the given `resource_handle` representing an iterator to a variant tensor.
+
+resource_handle: A handle to an iterator resource.
+serialized: A variant tensor storing the state of the iterator contained in the
+  resource.
+)doc");
+
+REGISTER_OP("DeserializeIterator")
+    .Input("resource_handle: resource")
+    .Input("serialized: variant")
+    .SetShapeFn(shape_inference::NoOutputs)
+    .Doc(R"doc(
+Converts the given variant tensor to an iterator and stores it in the given resource.
+
+resource_handle: A handle to an iterator resource.
+serialized: A variant tensor storing the state of the iterator contained in the
+  resource.
+)doc");
+
+}  // namespace tensorflow
diff --git a/tensorflow/contrib/data/python/kernel_tests/dataset_serialization_test_base.py b/tensorflow/contrib/data/python/kernel_tests/dataset_serialization_test_base.py
index 8713640985b1e23da378603af265eec894023e34..df9147af6c03925ac9f372c561000eaa6e7f328e 100644
--- a/tensorflow/contrib/data/python/kernel_tests/dataset_serialization_test_base.py
+++ b/tensorflow/contrib/data/python/kernel_tests/dataset_serialization_test_base.py
@@ -206,9 +206,16 @@ class DatasetSerializationTestBase(test.TestCase):
     # Generate `break_point` items from ds_fn1 and save checkpoint.
     self.gen_outputs(ds_fn1, [], break_point)
 
+    actual = []
     # Build graph for ds_fn2 but load checkpoint for ds_fn1.
-    actual = self.gen_outputs(
-        ds_fn2, [], break_point, ckpt_saved=True, verify_exhausted=True)
+    with ops.Graph().as_default() as g:
+      _, get_next_op, saver = self._build_graph(ds_fn2)
+      with self.test_session(graph=g) as sess:
+        self._restore(saver, sess)
+        for _ in range(num_outputs - break_point):
+          actual.append(sess.run(get_next_op))
+        with self.assertRaises(errors.OutOfRangeError):
+          sess.run(get_next_op)
 
     self.match(expected, actual)
 
diff --git a/tensorflow/contrib/data/python/kernel_tests/iterator_ops_test.py b/tensorflow/contrib/data/python/kernel_tests/iterator_ops_test.py
index bda9a2a4a37e9c3d35ff99041d1150ffc43f4c43..271d80a54b5a3e1a09cdf37e4f5e659fb67a78f9 100644
--- a/tensorflow/contrib/data/python/kernel_tests/iterator_ops_test.py
+++ b/tensorflow/contrib/data/python/kernel_tests/iterator_ops_test.py
@@ -21,6 +21,7 @@ import os
 import numpy as np
 
 from tensorflow.contrib.data.python.ops import dataset_ops
+from tensorflow.contrib.data.python.ops import gen_dataset_ops
 from tensorflow.contrib.data.python.ops import readers
 from tensorflow.core.protobuf import config_pb2
 from tensorflow.python.client import session
@@ -33,7 +34,6 @@ from tensorflow.python.framework import ops
 from tensorflow.python.framework import test_util
 from tensorflow.python.ops import array_ops
 from tensorflow.python.ops import functional_ops
-from tensorflow.python.ops import gen_dataset_ops
 from tensorflow.python.ops import gradients_impl
 from tensorflow.python.ops import io_ops
 from tensorflow.python.ops import math_ops
diff --git a/tensorflow/contrib/data/python/kernel_tests/range_dataset_op_test.py b/tensorflow/contrib/data/python/kernel_tests/range_dataset_op_test.py
index f59ac760dc83a504e563f055b91f1002cb0c80fc..329dc80ba5a29ade74ae8dfd12d37e5c1e2a9f73 100644
--- a/tensorflow/contrib/data/python/kernel_tests/range_dataset_op_test.py
+++ b/tensorflow/contrib/data/python/kernel_tests/range_dataset_op_test.py
@@ -21,6 +21,7 @@ import os
 
 from tensorflow.contrib.data.python.ops import dataset_ops
 from tensorflow.contrib.data.python.ops import enumerate_ops
+from tensorflow.contrib.data.python.ops import gen_dataset_ops
 from tensorflow.contrib.data.python.ops import iterator_ops as contrib_iterator_ops
 from tensorflow.python.data.ops import iterator_ops
 from tensorflow.python.framework import constant_op
@@ -29,7 +30,6 @@ from tensorflow.python.framework import errors
 from tensorflow.python.framework import ops
 from tensorflow.python.framework import tensor_shape
 from tensorflow.python.ops import array_ops
-from tensorflow.python.ops import gen_dataset_ops
 from tensorflow.python.ops import io_ops
 from tensorflow.python.ops import parsing_ops
 from tensorflow.python.ops import variables
diff --git a/tensorflow/contrib/data/python/kernel_tests/reader_dataset_ops_test.py b/tensorflow/contrib/data/python/kernel_tests/reader_dataset_ops_test.py
index 3ae8f71d77fa6ecf08e42bedac702b8f75eec309..8033f1d38806767ce08043d10c42dd376087765c 100644
--- a/tensorflow/contrib/data/python/kernel_tests/reader_dataset_ops_test.py
+++ b/tensorflow/contrib/data/python/kernel_tests/reader_dataset_ops_test.py
@@ -21,6 +21,7 @@ import gzip
 import os
 import zlib
 
+from tensorflow.contrib.data.python.ops import gen_dataset_ops
 from tensorflow.contrib.data.python.ops import iterator_ops as contrib_iterator_ops
 from tensorflow.contrib.data.python.ops import readers
 from tensorflow.core.example import example_pb2
@@ -33,7 +34,6 @@ from tensorflow.python.framework import ops
 from tensorflow.python.framework import tensor_shape
 from tensorflow.python.lib.io import python_io
 from tensorflow.python.ops import array_ops
-from tensorflow.python.ops import gen_dataset_ops
 from tensorflow.python.ops import io_ops
 from tensorflow.python.ops import parsing_ops
 from tensorflow.python.platform import test
diff --git a/tensorflow/contrib/data/python/ops/BUILD b/tensorflow/contrib/data/python/ops/BUILD
index 1b81cf5be9190ffab646192fb9a72fd3da7deee1..727c5d1c38ba30c32968a3cf33f7c03163f060d4 100644
--- a/tensorflow/contrib/data/python/ops/BUILD
+++ b/tensorflow/contrib/data/python/ops/BUILD
@@ -11,20 +11,6 @@ load(
 )
 load("//tensorflow:tensorflow.bzl", "tf_custom_op_py_library")
 
-py_library(
-    name = "dataset_ops",
-    srcs = [
-        "dataset_ops.py",
-    ],
-    srcs_version = "PY2AND3",
-    deps = [
-        ":transformation_ops",
-        "//tensorflow/python:util",
-        "//tensorflow/python/data/ops:dataset_ops",
-        "//tensorflow/python/data/util:nest",
-    ],
-)
-
 py_library(
     name = "iterator_ops",
     srcs = [
@@ -73,6 +59,7 @@ py_library(
     ],
     srcs_version = "PY2AND3",
     deps = [
+        ":gen_dataset_ops",
         "//tensorflow/python:array_ops",
         "//tensorflow/python:control_flow_ops",
         "//tensorflow/python:dataset_ops_gen",
@@ -128,6 +115,31 @@ tf_custom_op_py_library(
     ],
 )
 
+tf_gen_op_wrapper_py(
+    name = "gen_dataset_ops",
+    out = "gen_dataset_ops.py",
+    deps = ["//tensorflow/contrib/data:dataset_ops_op_lib"],
+)
+
+tf_custom_op_py_library(
+    name = "dataset_ops",
+    srcs = ["dataset_ops.py"],
+    dso = ["//tensorflow/contrib/data:_dataset_ops.so"],
+    kernels = [
+        "//tensorflow/contrib/data:dataset_ops_op_lib",
+    ],
+    srcs_version = "PY2AND3",
+    deps = [
+        ":gen_dataset_ops",
+        ":transformation_ops",
+        "//tensorflow/contrib/util:util_py",
+        "//tensorflow/python:platform",
+        "//tensorflow/python:util",
+        "//tensorflow/python/data/ops:dataset_ops",
+        "//tensorflow/python/data/util:nest",
+    ],
+)
+
 filegroup(
     name = "all_files",
     srcs = glob(
diff --git a/tensorflow/contrib/data/python/ops/batching.py b/tensorflow/contrib/data/python/ops/batching.py
index abc9212a87550745490b974d25a929a66287f785..e6e5f716b62b8d715eecf0c5a79d1c22d34c06b2 100644
--- a/tensorflow/contrib/data/python/ops/batching.py
+++ b/tensorflow/contrib/data/python/ops/batching.py
@@ -17,6 +17,7 @@ from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
+from tensorflow.contrib.data.python.ops import gen_dataset_ops
 from tensorflow.python.data.ops import dataset_ops
 from tensorflow.python.data.util import nest
 from tensorflow.python.framework import dtypes
@@ -24,7 +25,6 @@ from tensorflow.python.framework import ops
 from tensorflow.python.framework import tensor_shape
 from tensorflow.python.framework import tensor_util
 from tensorflow.python.ops import array_ops
-from tensorflow.python.ops import gen_dataset_ops
 from tensorflow.python.ops import math_ops
 
 
diff --git a/tensorflow/contrib/data/python/ops/dataset_ops.py b/tensorflow/contrib/data/python/ops/dataset_ops.py
index 45d6dbe7438957029b4d6b71e181cb1fc3596ecb..c4c4426809aa7b5a1c80a0d6f797b9e140be4dea 100644
--- a/tensorflow/contrib/data/python/ops/dataset_ops.py
+++ b/tensorflow/contrib/data/python/ops/dataset_ops.py
@@ -20,15 +20,21 @@ from __future__ import print_function
 from tensorflow.contrib.data.python.ops import batching
 from tensorflow.contrib.data.python.ops import enumerate_ops
 from tensorflow.contrib.data.python.ops import error_ops
+from tensorflow.contrib.data.python.ops import gen_dataset_ops
 from tensorflow.contrib.data.python.ops import grouping
 
+from tensorflow.contrib.util import loader
 from tensorflow.python.data.ops import dataset_ops
 from tensorflow.python.data.util import nest
-from tensorflow.python.ops import gen_dataset_ops
 from tensorflow.python.ops import gen_io_ops
+from tensorflow.python.platform import resource_loader
 from tensorflow.python.util import deprecation
 
 
+_dataset_ops = loader.load_op_library(
+    resource_loader.get_path_to_datafile("../../_dataset_ops.so"))
+
+
 class Dataset(dataset_ops.Dataset):
   """Represents a potentially large set of elements.
 
diff --git a/tensorflow/contrib/data/python/ops/error_ops.py b/tensorflow/contrib/data/python/ops/error_ops.py
index 238bb52b0205f9ab66f479f1b92e72ab6e38725b..51a279107235f95eba2030291aab9d294f6d2b2d 100644
--- a/tensorflow/contrib/data/python/ops/error_ops.py
+++ b/tensorflow/contrib/data/python/ops/error_ops.py
@@ -17,9 +17,9 @@ from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
+from tensorflow.contrib.data.python.ops import gen_dataset_ops
 from tensorflow.python.data.ops import dataset_ops
 from tensorflow.python.data.util import nest
-from tensorflow.python.ops import gen_dataset_ops
 
 
 def ignore_errors():
diff --git a/tensorflow/contrib/data/python/ops/grouping.py b/tensorflow/contrib/data/python/ops/grouping.py
index 6df7b22fb69bb14c41a26bd630a825442f67ee23..1c7c94b3c84a8c48ba9237c323fc13777d25f43d 100644
--- a/tensorflow/contrib/data/python/ops/grouping.py
+++ b/tensorflow/contrib/data/python/ops/grouping.py
@@ -17,12 +17,12 @@ from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
+from tensorflow.contrib.data.python.ops import gen_dataset_ops
 from tensorflow.python.data.ops import dataset_ops
 from tensorflow.python.data.util import nest
 from tensorflow.python.framework import dtypes
 from tensorflow.python.framework import function
 from tensorflow.python.framework import ops
-from tensorflow.python.ops import gen_dataset_ops
 
 
 def group_by_window(key_func,
diff --git a/tensorflow/contrib/data/python/ops/interleave_ops.py b/tensorflow/contrib/data/python/ops/interleave_ops.py
index 74a919c1fff62cfa79b0877a3d081077ca6776f0..ce23e95697c9116635e6335dc7b1fdc6de514732 100644
--- a/tensorflow/contrib/data/python/ops/interleave_ops.py
+++ b/tensorflow/contrib/data/python/ops/interleave_ops.py
@@ -17,12 +17,12 @@ from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
+from tensorflow.contrib.data.python.ops import gen_dataset_ops
 from tensorflow.python.data.ops import dataset_ops
 from tensorflow.python.data.util import nest
 from tensorflow.python.framework import dtypes
 from tensorflow.python.framework import function
 from tensorflow.python.framework import ops
-from tensorflow.python.ops import gen_dataset_ops
 from tensorflow.python.util import deprecation
 
 
diff --git a/tensorflow/contrib/data/python/ops/iterator_ops.py b/tensorflow/contrib/data/python/ops/iterator_ops.py
index d736029fb035e573b70e8b19570e4e8ceca3c005..32d2f42c9352fa35e3671ed549ad85efce2546d7 100644
--- a/tensorflow/contrib/data/python/ops/iterator_ops.py
+++ b/tensorflow/contrib/data/python/ops/iterator_ops.py
@@ -17,8 +17,8 @@ from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
+from tensorflow.contrib.data.python.ops import gen_dataset_ops
 from tensorflow.python.framework import ops
-from tensorflow.python.ops import gen_dataset_ops
 from tensorflow.python.training import saver
 
 
diff --git a/tensorflow/contrib/data/python/ops/readers.py b/tensorflow/contrib/data/python/ops/readers.py
index 2e1c3153ca78e20e2628e8754b9827b817f8c732..f22298b757c73dac096603335b475119e5971df4 100644
--- a/tensorflow/contrib/data/python/ops/readers.py
+++ b/tensorflow/contrib/data/python/ops/readers.py
@@ -18,6 +18,7 @@ from __future__ import division
 from __future__ import print_function
 
 from tensorflow.contrib.data.python.ops import dataset_ops as contrib_dataset_ops
+from tensorflow.contrib.data.python.ops import gen_dataset_ops
 from tensorflow.python.data.ops import dataset_ops
 from tensorflow.python.data.ops import readers
 from tensorflow.python.data.util import nest
@@ -25,7 +26,6 @@ from tensorflow.python.framework import dtypes
 from tensorflow.python.framework import ops
 from tensorflow.python.framework import sparse_tensor as sparse_tensor_lib
 from tensorflow.python.framework import tensor_shape
-from tensorflow.python.ops import gen_dataset_ops
 from tensorflow.python.ops import parsing_ops
 from tensorflow.python.platform import gfile
 from tensorflow.python.util import deprecation
diff --git a/tensorflow/contrib/data/python/ops/scan_ops.py b/tensorflow/contrib/data/python/ops/scan_ops.py
index 5acaed48a3d73e93706bdd0b5b2d614b0c565ab7..87bbbb7d19b15955b507308ce2ea286f602efd37 100644
--- a/tensorflow/contrib/data/python/ops/scan_ops.py
+++ b/tensorflow/contrib/data/python/ops/scan_ops.py
@@ -19,11 +19,11 @@ from __future__ import print_function
 
 import collections
 
+from tensorflow.contrib.data.python.ops import gen_dataset_ops
 from tensorflow.python.data.ops import dataset_ops
 from tensorflow.python.data.util import nest
 from tensorflow.python.framework import function
 from tensorflow.python.framework import ops
-from tensorflow.python.ops import gen_dataset_ops
 
 
 class _ScanDataset(dataset_ops.Dataset):
diff --git a/tensorflow/contrib/eager/python/examples/mnist/mnist.py b/tensorflow/contrib/eager/python/examples/mnist/mnist.py
index 3dd920415df8b6d367d690132b647318ab8ba25b..bfb7d5a9002787f6544d383de58150661ac2bde3 100644
--- a/tensorflow/contrib/eager/python/examples/mnist/mnist.py
+++ b/tensorflow/contrib/eager/python/examples/mnist/mnist.py
@@ -191,9 +191,9 @@ def main(_):
     train_dir = None
     test_dir = None
   summary_writer = tf.contrib.summary.create_summary_file_writer(
-      train_dir, flush_secs=10)
+      train_dir, flush_millis=10000)
   test_summary_writer = tf.contrib.summary.create_summary_file_writer(
-      test_dir, flush_secs=10, name='test')
+      test_dir, flush_millis=10000, name='test')
   checkpoint_prefix = os.path.join(FLAGS.checkpoint_dir, 'ckpt')
 
   with tf.device(device):
diff --git a/tensorflow/contrib/eager/python/examples/rnn_colorbot/rnn_colorbot.py b/tensorflow/contrib/eager/python/examples/rnn_colorbot/rnn_colorbot.py
index 318962c634e0d050b35da5efc405400380c1b759..609cbd28772c3ae8da70648ca5b1b264a8a255e2 100644
--- a/tensorflow/contrib/eager/python/examples/rnn_colorbot/rnn_colorbot.py
+++ b/tensorflow/contrib/eager/python/examples/rnn_colorbot/rnn_colorbot.py
@@ -248,9 +248,9 @@ def main(_):
   log_dir = os.path.join(FLAGS.dir, "summaries")
   tf.gfile.MakeDirs(log_dir)
   train_summary_writer = tf.contrib.summary.create_summary_file_writer(
-      os.path.join(log_dir, "train"), flush_secs=10)
+      os.path.join(log_dir, "train"), flush_millis=10000)
   test_summary_writer = tf.contrib.summary.create_summary_file_writer(
-      os.path.join(log_dir, "eval"), flush_secs=10, name="eval")
+      os.path.join(log_dir, "eval"), flush_millis=10000, name="eval")
 
   with tf.device(device):
     for epoch in range(FLAGS.num_epochs):
diff --git a/tensorflow/contrib/eager/python/network.py b/tensorflow/contrib/eager/python/network.py
index 97feaec30ed066503ef8ce75cbd5af04ea2ef6bf..c6e628b074e8638fd15a35f2df87609e0ad46000 100644
--- a/tensorflow/contrib/eager/python/network.py
+++ b/tensorflow/contrib/eager/python/network.py
@@ -182,6 +182,40 @@ def _make_custom_getter_for_deferred_restorations():
   return _custom_getter, deferred_restorations
 
 
+def _make_prefix_stripping_map_fn(scope_name):
+  """Closure for stripping the scope name of a Network.
+
+  Implemented as a closure rather than a member function to avoid reference
+  cycles in deferred restorations (this function should not have a reference to
+  the Network which created it).
+
+  Args:
+    scope_name: The Network.scope_name to strip from variables.
+  Returns:
+    A scope_name-stripping default `map_fn` for the Network.
+  """
+
+  def _strip_variable_prefix(original_variable_name):
+    """The default map_func for saving or restoring variables.
+
+    Strips the variable prefix for the Network on which save/restore was called,
+    and leaves other variable names fully qualified in the checkpoint.
+
+    Args:
+      original_variable_name: The _shared_name of the variable (no :0
+        suffix) to map.
+    Returns:
+      The checkpoint name of the variable.
+    """
+    scope_name_with_slash = scope_name + "/"
+    if original_variable_name.startswith(scope_name_with_slash):
+      return original_variable_name[len(scope_name_with_slash):]
+    else:
+      return original_variable_name
+
+  return _strip_variable_prefix
+
+
 class Network(base.Layer):
   """Represents the composition of a set of Layers.
 
@@ -488,24 +522,6 @@ class Network(base.Layer):
         "at https://github.com/tensorflow/tensorflow/issues/new if this is "
         "important to you")
 
-  def _strip_variable_prefix(self, original_variable_name):
-    """The default map_func for saving or restoring variables.
-
-    Strips the variable prefix for the Network on which save/restore was called,
-    and leaves other variable names fully qualified in the checkpoint.
-
-    Args:
-      original_variable_name: The _shared_name of the variable (no :0
-        suffix) to map.
-    Returns:
-      The checkpoint name of the variable.
-    """
-    scope_name_with_slash = self.scope_name + "/"
-    if original_variable_name.startswith(scope_name_with_slash):
-      return original_variable_name[len(scope_name_with_slash):]
-    else:
-      return original_variable_name
-
   def save(self, save_path, global_step=None, map_func=None):
     """Save variables from the Network to a checkpoint.
 
@@ -543,7 +559,7 @@ class Network(base.Layer):
       save_path = os.path.join(save_path, self.name)
     user_map_func = map_func
     if map_func is None:
-      map_func = self._strip_variable_prefix
+      map_func = _make_prefix_stripping_map_fn(self.scope_name)
     variable_map = {}
     for variable in self.variables:
       mapped_name = map_func(variable._shared_name)
@@ -737,7 +753,7 @@ class Network(base.Layer):
       save_path = os.path.join(save_path, self.name)
     user_map_func = map_func
     if map_func is None:
-      map_func = self._strip_variable_prefix
+      map_func = _make_prefix_stripping_map_fn(self.scope_name)
     # Step one is to restore any existing variables from the checkpoint.
     existing_variables_by_checkpoint_name = self._restore_existing_variables(
         save_path=save_path,
diff --git a/tensorflow/contrib/eager/python/network_test.py b/tensorflow/contrib/eager/python/network_test.py
index c621f527c28306131bdba56d8427eaa787ba150b..14adbafe5735bd2a3d3961402e8ef3e6a7be333b 100644
--- a/tensorflow/contrib/eager/python/network_test.py
+++ b/tensorflow/contrib/eager/python/network_test.py
@@ -67,7 +67,7 @@ class NetworkTest(test.TestCase):
         original_output,
         self.evaluate(net(input_value)))
 
-  @test_util.run_in_graph_and_eager_modes()
+  @test_util.run_in_graph_and_eager_modes(assert_no_eager_garbage=True)
   def testTrainableAttribute(self):
     net = network.Network()
     self.assertTrue(net.trainable)
@@ -75,7 +75,7 @@ class NetworkTest(test.TestCase):
       net.trainable = False
     self.assertTrue(net.trainable)
 
-  @test_util.run_in_graph_and_eager_modes()
+  @test_util.run_in_graph_and_eager_modes(assert_no_eager_garbage=True)
   def testNetworkCall(self):
     net = MyNetwork(name="abcd")
     net(constant_op.constant([[2.0]]))  # Force variables to be created.
@@ -85,6 +85,7 @@ class NetworkTest(test.TestCase):
     result = net(constant_op.constant([[2.0]]))
     self.assertEqual(34.0, self.evaluate(result))
 
+  # TODO(allenl): This test creates garbage in some Python versions
   @test_util.run_in_graph_and_eager_modes()
   def testNetworkSaveRestoreAlreadyBuilt(self):
     net = MyNetwork(name="abcd")
@@ -96,6 +97,7 @@ class NetworkTest(test.TestCase):
     self._save_modify_load_network_built(net, global_step=None)
     self._save_modify_load_network_built(net, global_step=10)
 
+  # TODO(allenl): This test creates garbage in some Python versions
   @test_util.run_in_graph_and_eager_modes()
   def testSaveRestoreDefaultGlobalStep(self):
     net = MyNetwork(name="abcd")
@@ -106,6 +108,7 @@ class NetworkTest(test.TestCase):
     save_path = net.save(self.get_temp_dir())
     self.assertIn("abcd-4242", save_path)
 
+  # TODO(allenl): This test creates garbage in some Python versions
   @test_util.run_in_graph_and_eager_modes()
   def testNetworkSaveAndRestoreIntoUnbuilt(self):
     save_dir = self.get_temp_dir()
@@ -377,25 +380,25 @@ class NetworkTest(test.TestCase):
     gc.set_debug(previous_gc_debug_flags)
     gc.enable()
 
-  @test_util.run_in_graph_and_eager_modes()
+  @test_util.run_in_graph_and_eager_modes(assert_no_eager_garbage=True)
   def testAnonymousNoNameInitially(self):
     net = MyNetwork()
     with self.assertRaisesRegexp(ValueError, "does not yet have a final name"):
       net.name  # pylint: disable=pointless-statement
 
-  @test_util.run_in_graph_and_eager_modes()
+  @test_util.run_in_graph_and_eager_modes(assert_no_eager_garbage=True)
   def testExplicitHasNameInitially(self):
     net = MyNetwork(name="abcd")
     self.assertEqual("abcd", net.name)
 
-  @test_util.run_in_graph_and_eager_modes()
+  @test_util.run_in_graph_and_eager_modes(assert_no_eager_garbage=True)
   def testUsingResourceVariables(self):
     net = MyNetwork()
     net(constant_op.constant([[0.]]))
     self.assertIsInstance(net.trainable_weights[0],
                           resource_variable_ops.ResourceVariable)
 
-  @test_util.run_in_graph_and_eager_modes()
+  @test_util.run_in_graph_and_eager_modes(assert_no_eager_garbage=True)
   def testDuplicateNameError(self):
     one = constant_op.constant([[1.]])
     net = MyNetwork(name="foo")
@@ -405,7 +408,7 @@ class NetworkTest(test.TestCase):
       net1 = MyNetwork(name="foo")
       net1(one)
 
-  @test_util.run_in_graph_and_eager_modes()
+  @test_util.run_in_graph_and_eager_modes(assert_no_eager_garbage=True)
   def testWrappingInVariableScope(self):
     with variable_scope.variable_scope("outside_scope"):
       net = MyNetwork()
@@ -440,7 +443,7 @@ class NetworkTest(test.TestCase):
                           actual=net.trainable_weights[0].name)
     self.assertEqual("explicit_name", net.first.name)
 
-  @test_util.run_in_graph_and_eager_modes()
+  @test_util.run_in_graph_and_eager_modes(assert_no_eager_garbage=True)
   def testWrappingInAnonymousVariableScope(self):
     # Named outside variable_scopes are not supported at the moment. However,
     # blank-named top level variable scopes do not change variable names, and so
@@ -455,20 +458,20 @@ class NetworkTest(test.TestCase):
       net(one)
     self.assertTrue(was_called[0])
 
-  @test_util.run_in_graph_and_eager_modes()
+  @test_util.run_in_graph_and_eager_modes(assert_no_eager_garbage=True)
   def testReasonableSlashError(self):
     with self.assertRaisesRegexp(
         ValueError, "not allowed in Network names"):
       MyNetwork(name="slash/slash")
 
-  @test_util.run_in_graph_and_eager_modes()
+  @test_util.run_in_graph_and_eager_modes(assert_no_eager_garbage=True)
   def testNoVariableScopeNames(self):
     with self.assertRaisesRegexp(
         ValueError, "VariableScopes are not valid Network names"):
       with variable_scope.variable_scope("some_scope") as vs:
         MyNetwork(name=vs)
 
-  @test_util.run_in_graph_and_eager_modes()
+  @test_util.run_in_graph_and_eager_modes(assert_no_eager_garbage=True)
   def testVariableScopeNameCollision(self):
     with variable_scope.variable_scope("abcd"):
       pass
@@ -478,7 +481,7 @@ class NetworkTest(test.TestCase):
       one = constant_op.constant([[1.]])
       net(one)
 
-  @test_util.run_in_graph_and_eager_modes()
+  @test_util.run_in_graph_and_eager_modes(assert_no_eager_garbage=True)
   def testNetworkVariablesDoNotInterfere(self):
     core.Dense(1, use_bias=True)  # Should not interfere with naming.
     net1 = MyNetwork()
@@ -1007,6 +1010,7 @@ class NetworkTest(test.TestCase):
 
 class SequentialTest(test.TestCase):
 
+  @test_util.assert_no_garbage_created
   def testTwoLayers(self):
     # Create a sequential network with one layer.
     net = network.Sequential([core.Dense(1, use_bias=False)])
@@ -1028,6 +1032,7 @@ class SequentialTest(test.TestCase):
     l2.trainable_variables[0].assign([[11.0]])
     self.assertEqual(231.0, net(constant_op.constant([[7.0]])).numpy())
 
+  @test_util.assert_no_garbage_created
   def testFunctions(self):
     # Create a sequential network with one function.
     net = network.Sequential([nn_ops.relu])
@@ -1038,6 +1043,7 @@ class SequentialTest(test.TestCase):
     net.add(math_ops.negative)
     self.assertEqual(-2.0, net(two).numpy())
 
+  @test_util.assert_no_garbage_created
   def testTrainingLayer(self):
     net = network.Sequential([core.Dropout(0.99999)])
     two = constant_op.constant(2.0)
@@ -1051,6 +1057,7 @@ class SequentialTest(test.TestCase):
     # Should only fail spuriously 1 in 10^100 runs.
     self.fail("Didn't see dropout happen after 20 tries.")
 
+  @test_util.assert_no_garbage_created
   def testTrainingFunction(self):
     # Output depends on value of "training".
     def add_training(input_value, training=None):
diff --git a/tensorflow/contrib/estimator/BUILD b/tensorflow/contrib/estimator/BUILD
index a0f83ac10555913b5be177f0f2b00b2b0e30494a..6eb2cfdaca7840c4a5dd8cffc9620aaf3f96a1de 100644
--- a/tensorflow/contrib/estimator/BUILD
+++ b/tensorflow/contrib/estimator/BUILD
@@ -7,6 +7,7 @@ package(
 licenses(["notice"])  # Apache 2.0
 
 load("//tensorflow:tensorflow.bzl", "py_test")
+load("//tensorflow:tensorflow.bzl", "cuda_py_test")
 
 filegroup(
     name = "all_files",
@@ -30,6 +31,7 @@ py_library(
         ":head",
         ":logit_fns",
         ":multi_head",
+        ":replicate_model_fn",
         "//tensorflow/python:util",
     ],
 )
@@ -227,9 +229,69 @@ py_test(
         "//tensorflow/python:string_ops",
         "//tensorflow/python/estimator:metric_keys",
         "//tensorflow/python/estimator:model_fn",
-        "//tensorflow/python/estimator:prediction_keys",
+        "//tensorflow/python/ops/losses",
         "//tensorflow/python/saved_model:signature_constants",
         "//third_party/py/numpy",
         "@six_archive//:six",
     ],
 )
+
+py_library(
+    name = "replicate_model_fn",
+    srcs = [
+        "python/estimator/replicate_model_fn.py",
+    ],
+    srcs_version = "PY2AND3",
+    deps = [
+        "//tensorflow/core:protos_all_py",
+        "//tensorflow/python:array_ops",
+        "//tensorflow/python:control_flow_ops",
+        "//tensorflow/python:device",
+        "//tensorflow/python:device_lib",
+        "//tensorflow/python:framework_ops",
+        "//tensorflow/python:gradients",
+        "//tensorflow/python:math_ops",
+        "//tensorflow/python:platform",
+        "//tensorflow/python:state_ops",
+        "//tensorflow/python:training",
+        "//tensorflow/python:variable_scope",
+        "//tensorflow/python:variables",
+        "//tensorflow/python/estimator:export_output",
+        "//tensorflow/python/estimator:model_fn",
+        "//tensorflow/python/estimator:util",
+        "@six_archive//:six",
+    ],
+)
+
+cuda_py_test(
+    name = "replicate_model_fn_test",
+    size = "small",
+    srcs = ["python/estimator/replicate_model_fn_test.py"],
+    additional_deps = [
+        "//tensorflow/python/estimator",
+        "//tensorflow/python/estimator:dnn",
+        "//tensorflow/python/estimator:export_export",
+        "//tensorflow/python/estimator:export_output",
+        "//tensorflow/python/estimator:model_fn",
+        "//tensorflow/python/estimator:numpy_io",
+        "//tensorflow/python/estimator:optimizers",
+        "//tensorflow/python/estimator:prediction_keys",
+        "//tensorflow/python/feature_column",
+        "//tensorflow/python/ops/losses",
+        "//tensorflow/python/saved_model:signature_constants",
+        "//tensorflow/python:array_ops",
+        "//tensorflow/python:client_testlib",
+        "//tensorflow/python:control_flow_ops",
+        "//tensorflow/python:framework_for_generated_wrappers",
+        "//tensorflow/python:framework_test_lib",
+        "//tensorflow/python:math_ops",
+        "//tensorflow/python:metrics",
+        "//tensorflow/python:platform",
+        "//tensorflow/python:summary",
+        "//tensorflow/python:training",
+        "//tensorflow/python:variable_scope",
+        "//tensorflow/python:variables",
+        ":replicate_model_fn",
+    ],
+    tags = ["requires-gpu-sm35"],
+)
diff --git a/tensorflow/contrib/estimator/python/estimator/head.py b/tensorflow/contrib/estimator/python/estimator/head.py
index 7c992c99ed3fb05d5f2c306304b7084584c201e4..e344ee3c3eab22d217570a8c8073f72998e77b03 100644
--- a/tensorflow/contrib/estimator/python/estimator/head.py
+++ b/tensorflow/contrib/estimator/python/estimator/head.py
@@ -172,7 +172,8 @@ def multi_label_head(n_classes,
     weight_column: A string or a `_NumericColumn` created by
       `tf.feature_column.numeric_column` defining feature column representing
       weights. It is used to down weight or boost examples during training. It
-      will be multiplied by the loss of the example.
+      will be multiplied by the loss of the example.  Per-class weighting is
+      not supported.
     thresholds: Iterable of floats in the range `(0, 1)`. Accuracy, precision
       and recall metrics are evaluated for each threshold value. The threshold
       is applied to the predicted probabilities, i.e. above the threshold is
diff --git a/tensorflow/contrib/estimator/python/estimator/head_test.py b/tensorflow/contrib/estimator/python/estimator/head_test.py
index 972ce6163d5b0f580b08888bd69dff0d40fefa34..fd8c53f6a94bf741c02e814ca96bfcea050589c4 100644
--- a/tensorflow/contrib/estimator/python/estimator/head_test.py
+++ b/tensorflow/contrib/estimator/python/estimator/head_test.py
@@ -226,7 +226,7 @@ class MultiLabelHead(test.TestCase):
 
   def test_weight_should_not_impact_prediction(self):
     n_classes = 4
-    head = head_lib.multi_label_head(n_classes, weight_column='label_weights')
+    head = head_lib.multi_label_head(n_classes, weight_column='example_weights')
     self.assertEqual(n_classes, head.logits_dimension)
 
     logits = np.array(
@@ -237,7 +237,7 @@ class MultiLabelHead(test.TestCase):
     spec = head.create_estimator_spec(
         features={
             'x': np.array(((42,),), dtype=np.int32),
-            'label_weights': weights_2x1,
+            'example_weights': weights_2x1,
         },
         mode=model_fn.ModeKeys.PREDICT,
         logits=logits)
@@ -549,7 +549,7 @@ class MultiLabelHead(test.TestCase):
 
   def test_eval_with_weights(self):
     n_classes = 2
-    head = head_lib.multi_label_head(n_classes, weight_column='label_weights')
+    head = head_lib.multi_label_head(n_classes, weight_column='example_weights')
 
     logits = np.array([[-10., 10.], [-15., 10.]], dtype=np.float32)
     labels = np.array([[1, 0], [1, 1]], dtype=np.int64)
@@ -563,7 +563,7 @@ class MultiLabelHead(test.TestCase):
     spec = head.create_estimator_spec(
         features={
             'x': np.array([[41], [42]], dtype=np.int32),
-            'label_weights': np.array([[1.], [2.]], dtype=np.float32),
+            'example_weights': np.array([[1.], [2.]], dtype=np.float32),
         },
         mode=model_fn.ModeKeys.EVAL,
         logits=logits,
@@ -605,7 +605,7 @@ class MultiLabelHead(test.TestCase):
   def test_train_create_loss_large_logits(self):
     """Tests head.create_loss for train mode and large logits."""
     n_classes = 2
-    head = head_lib.multi_label_head(n_classes, weight_column='label_weights')
+    head = head_lib.multi_label_head(n_classes, weight_column='example_weights')
 
     logits = np.array([[-10., 10.], [-15., 10.]], dtype=np.float32)
     labels = np.array([[1, 0], [1, 1]], dtype=np.int64)
@@ -623,7 +623,7 @@ class MultiLabelHead(test.TestCase):
     actual_weighted_sum_loss, actual_example_weight_sum, _ = head.create_loss(
         features={
             'x': np.array(((42,),), dtype=np.int32),
-            'label_weights': weights
+            'example_weights': weights
         },
         mode=model_fn.ModeKeys.TRAIN,
         logits=logits,
@@ -742,7 +742,7 @@ class MultiLabelHead(test.TestCase):
 
   def test_train_with_weights(self):
     n_classes = 2
-    head = head_lib.multi_label_head(n_classes, weight_column='label_weights')
+    head = head_lib.multi_label_head(n_classes, weight_column='example_weights')
 
     logits = np.array([[-10., 10.], [-15., 10.]], dtype=np.float32)
     labels = np.array([[1, 0], [1, 1]], dtype=np.int64)
@@ -761,7 +761,7 @@ class MultiLabelHead(test.TestCase):
     spec = head.create_estimator_spec(
         features={
             'x': np.array([[41], [42]], dtype=np.int32),
-            'label_weights': np.array([[1.], [2.]], dtype=np.float32),
+            'example_weights': np.array([[1.], [2.]], dtype=np.float32),
         },
         mode=model_fn.ModeKeys.TRAIN,
         logits=logits,
diff --git a/tensorflow/contrib/estimator/python/estimator/logit_fns.py b/tensorflow/contrib/estimator/python/estimator/logit_fns.py
index fc5efa4d7b98123ae968f98d4a54900e2d63570d..09c2862ccd3f90de4153a2095afc9c3d3f9476c1 100644
--- a/tensorflow/contrib/estimator/python/estimator/logit_fns.py
+++ b/tensorflow/contrib/estimator/python/estimator/logit_fns.py
@@ -84,7 +84,7 @@ def call_logit_fn(logit_fn, features, mode, params, config):
 
   result_is_valid_dictionary = (
       isinstance(logit_fn_results, dict) and
-      all([(isinstance(k, str) and isinstance(v, ops.Tensor))
+      all([(isinstance(k, six.string_types) and isinstance(v, ops.Tensor))
            for k, v in six.iteritems(logit_fn_results)]))
   result_is_tensor = isinstance(logit_fn_results, ops.Tensor)
 
diff --git a/tensorflow/contrib/estimator/python/estimator/logit_fns_test.py b/tensorflow/contrib/estimator/python/estimator/logit_fns_test.py
index 3279e920018bae8ca9520a6372f6b71971da7b52..074ece6cca2865b9057ab5ce874a210d3d9ac2e0 100644
--- a/tensorflow/contrib/estimator/python/estimator/logit_fns_test.py
+++ b/tensorflow/contrib/estimator/python/estimator/logit_fns_test.py
@@ -46,7 +46,7 @@ class LogitFnTest(test.TestCase):
   def test_simple_call_multi_logit_fn(self):
 
     def dummy_logit_fn(features):
-      return {'head1': features['f1'], 'head2': features['f2']}
+      return {u'head1': features['f1'], 'head2': features['f2']}
 
     features = {
         'f1': constant_op.constant([[2., 3.]]),
diff --git a/tensorflow/contrib/estimator/python/estimator/multi_head.py b/tensorflow/contrib/estimator/python/estimator/multi_head.py
index 64b2a9dee83801b5d6d852a3485fc0cc81417ff0..69dbfcee62af526cc92f8699f7137acbcdc03052 100644
--- a/tensorflow/contrib/estimator/python/estimator/multi_head.py
+++ b/tensorflow/contrib/estimator/python/estimator/multi_head.py
@@ -161,12 +161,52 @@ class _MultiHead(head_lib._Head):  # pylint:disable=protected-access
 
   def create_loss(self, features, mode, logits, labels):
     """See `Head`."""
-    # TODO(roumposg): Implement it.
-    raise NotImplementedError('create_loss not yet implemented for MultiHead.')
+    # TODO(roumposg): Add support for logits as single Tensor (with
+    # _split_logits utility).
+    if not isinstance(logits, dict):
+      raise ValueError('logits must be a dict.  Single Tensor support coming '
+                       'soon.')
+    weighted_sum_losses = []
+    example_weight_sums = []
+    labels_by_head = {}
+    for head in self._heads:
+      (weighted_sum_loss,
+       example_weight_sum, processed_labels) = head.create_loss(
+           features, mode, logits[head.name], labels[head.name])
+      weighted_sum_losses.append(weighted_sum_loss)
+      example_weight_sums.append(example_weight_sum)
+      labels_by_head[head.name] = processed_labels
+
+    weighted_sum_losses = tuple(weighted_sum_losses)
+    with ops.name_scope('merge_losses',
+                        values=weighted_sum_losses + (self._head_weights or
+                                                      tuple())):
+      if self._head_weights:
+        head_weighted_losses = []
+        head_weighted_example_weight_sums = []
+        for loss, example_weight_sum, weight in zip(weighted_sum_losses,
+                                                    example_weight_sums,
+                                                    self._head_weights):
+          head_weighted_losses.append(math_ops.multiply(loss, weight))
+          head_weighted_example_weight_sums.append(math_ops.multiply(
+              example_weight_sum, weight))
+        merged_weighted_sum_loss = math_ops.add_n(head_weighted_losses)
+        merged_example_weight_sum = math_ops.add_n(
+            head_weighted_example_weight_sums)
+      else:
+        merged_weighted_sum_loss = math_ops.add_n(weighted_sum_losses)
+        merged_example_weight_sum = math_ops.add_n(example_weight_sums)
+
+    return head_lib.LossSpec(
+        weighted_sum_loss=merged_weighted_sum_loss,
+        example_weight_sum=merged_example_weight_sum,
+        processed_labels=labels_by_head)
 
   def create_estimator_spec(
       self, features, mode, logits, labels=None, train_op_fn=None):
     """See `_Head`."""
+    # TODO(roumposg): Add support for logits as single Tensor (with
+    # _split_logits utility).
     if not isinstance(logits, dict):
       raise ValueError('logits must be a dict. Given: {}'.format(logits))
     if labels and not isinstance(labels, dict):
@@ -183,6 +223,8 @@ class _MultiHead(head_lib._Head):  # pylint:disable=protected-access
               labels=labels[head_name] if labels else None,
               train_op_fn=_no_op_train_fn))
 
+    # TODO(roumposg): Add LOSS and LOSS_MEAN summaries for the total head-
+    # combined loss.
     if mode == model_fn.ModeKeys.TRAIN:
       if train_op_fn is None:
         raise ValueError('train_op_fn can not be None in TRAIN mode.')
diff --git a/tensorflow/contrib/estimator/python/estimator/multi_head_test.py b/tensorflow/contrib/estimator/python/estimator/multi_head_test.py
index 48027035cecffc3ce8aacf8ae917f5eb9e9b2473..16177aebd53cbff5c8fd727477ac5d18c9f8bce5 100644
--- a/tensorflow/contrib/estimator/python/estimator/multi_head_test.py
+++ b/tensorflow/contrib/estimator/python/estimator/multi_head_test.py
@@ -178,7 +178,7 @@ class MultiHeadTest(test.TestCase):
     #        (1 - labels) * (logits > 0) * logits =>
     # head1: expected_unweighted_loss = [[10., 10.], [15., 0.]]
     # head2: expected_unweighted_loss = [[20., 20., 20.], [30., 0., 0]]
-    # Average over classes, weighted sum ober batch and heads.
+    # Average over classes, weighted sum over batch and heads.
     expected_loss_head1 = 17.5
     expected_loss_head2 = 30.0
     expected_loss = 1. * expected_loss_head1 + 2. * expected_loss_head2
@@ -231,18 +231,25 @@ class MultiHeadTest(test.TestCase):
 
     logits = {'head1': np.array([[-10., 10.], [-15., 10.]], dtype=np.float32)}
     labels = {'head1': np.array([[1, 0], [1, 1]], dtype=np.int64)}
-    with self.assertRaisesRegexp(
-        NotImplementedError,
-        r'create_loss not yet implemented for MultiHead\.'):
-      multi_head.create_loss(
-          features={'x': np.array(((42,),), dtype=np.int32)},
-          mode=model_fn.ModeKeys.TRAIN,
-          logits=logits,
-          labels=labels)
+    loss = multi_head.create_loss(
+        features={'x': np.array(((42,),), dtype=np.int32)},
+        mode=model_fn.ModeKeys.TRAIN,
+        logits=logits,
+        labels=labels)[0]
+    tol = 1e-3
+    with self.test_session():
+      # Unreduced loss of the head is [[(10 + 10) / 2], (15 + 0) / 2]
+      # (averaged over classes, sum-reduced over examples).
+      self.assertAllClose(17.5, loss.eval(), rtol=tol, atol=tol)
 
   def test_train_create_loss_two_heads_with_weights(self):
-    head1 = head_lib.multi_label_head(n_classes=2, name='head1')
-    head2 = head_lib.multi_label_head(n_classes=3, name='head2')
+    # Use different example weighting for each head weighting.
+    weights1 = np.array([[1.], [2.]], dtype=np.float32)
+    weights2 = np.array([[2.], [3.]])
+    head1 = head_lib.multi_label_head(n_classes=2, name='head1',
+                                      weight_column='weights1')
+    head2 = head_lib.multi_label_head(n_classes=3, name='head2',
+                                      weight_column='weights2')
     multi_head = multi_head_lib.multi_head(
         [head1, head2], head_weights=[1., 2.])
 
@@ -255,14 +262,27 @@ class MultiHeadTest(test.TestCase):
         'head1': np.array([[1, 0], [1, 1]], dtype=np.int64),
         'head2': np.array([[0, 1, 0], [1, 1, 0]], dtype=np.int64),
     }
-    with self.assertRaisesRegexp(
-        NotImplementedError,
-        r'create_loss not yet implemented for MultiHead\.'):
-      multi_head.create_loss(
-          features={'x': np.array(((42,),), dtype=np.int32)},
-          mode=model_fn.ModeKeys.TRAIN,
-          logits=logits,
-          labels=labels)
+    weighted_sum_loss, example_weight_sum, _ = multi_head.create_loss(
+        features={
+            'x': np.array(((42,),), dtype=np.int32),
+            'weights1': weights1,
+            'weights2': weights2
+        },
+        mode=model_fn.ModeKeys.TRAIN,
+        logits=logits,
+        labels=labels)
+    tol = 1e-3
+    with self.test_session():
+      # loss of the first head is [[(10 + 10) / 2], [(15 + 0) / 2]]
+      # = [10, 7.5]
+      # weighted_sum_loss = 1 * 10 + 2 * 7.5 = 25
+      # loss of the second head is [[(20 + 20 + 20) / 3], [(30 + 0 + 0) / 3]]
+      # = [20, 10]
+      # weighted_sum_loss = 2 * 20 + 3 * 10 = 70
+      # head-weighted merge = 1 * 25 + 2 * 70 = 165
+      self.assertAllClose(165, weighted_sum_loss.eval(), rtol=tol, atol=tol)
+      # example_weight_sum = 1 * (1 + 2) + 2 * (2 + 3) = 13
+      self.assertAllClose(13., example_weight_sum.eval(), rtol=tol, atol=tol)
 
   def test_train_one_head(self):
     head1 = head_lib.multi_label_head(n_classes=2, name='head1')
@@ -332,7 +352,7 @@ class MultiHeadTest(test.TestCase):
     #        (1 - labels) * (logits > 0) * logits =>
     # head1: expected_unweighted_loss = [[10., 10.], [15., 0.]]
     # head2: expected_unweighted_loss = [[20., 20., 20.], [30., 0., 0]]
-    # Average over classes, weighted sum ober batch and heads.
+    # Average over classes, weighted sum over batch and heads.
     expected_loss_head1 = 17.5
     expected_loss_head2 = 30.0
     expected_loss = 1. * expected_loss_head1 + 2. * expected_loss_head2
diff --git a/tensorflow/contrib/estimator/python/estimator/replicate_model_fn.py b/tensorflow/contrib/estimator/python/estimator/replicate_model_fn.py
new file mode 100644
index 0000000000000000000000000000000000000000..7005a647db599dfa386f34406911febe1d9d5651
--- /dev/null
+++ b/tensorflow/contrib/estimator/python/estimator/replicate_model_fn.py
@@ -0,0 +1,470 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Utilities to replicate model_fn's over local GPUs.
+
+This file contains util that allow to replicate `Estimator.model_fn` over
+GPUs.  Replicated version of a `model_fn` is returned that can subsequently
+be used with `Estimator`.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import copy
+
+import six
+
+from tensorflow.core.framework import node_def_pb2
+from tensorflow.python.client import device_lib
+from tensorflow.python.estimator import model_fn as model_fn_lib
+from tensorflow.python.estimator import util
+from tensorflow.python.estimator.export import export_output as export_output_lib
+from tensorflow.python.framework import device as framework_device
+from tensorflow.python.framework import ops as ops_lib
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import control_flow_ops
+from tensorflow.python.ops import gradients as gradients_lib
+from tensorflow.python.ops import math_ops
+from tensorflow.python.ops import state_ops
+from tensorflow.python.ops import variable_scope
+from tensorflow.python.ops import variables as variables_lib
+from tensorflow.python.platform import tf_logging
+from tensorflow.python.training import training_util
+
+
+def replicate_model_fn(model_fn, optimizer_fn, devices=None):
+  """Replicate `Estimator.model_fn` over GPUs within a single host.
+
+  The given `model_fn` specifies a single forward pass of a model.  To replicate
+  such a model over GPUs, each GPU gets its own instance of the forward pass
+  (a.k.a. a tower).  The input features and labels get sharded into the chunks
+  that correspond to the number of GPUs.  Each tower computes its own loss based
+  on its input.  For each such loss, gradients are computed.  After that, the
+  available losses are summed to form aggregated loss.  The available
+  gradients are summed too.  Then, they update weights using the specified
+  optimizer.
+
+  If `devices` are `None`, then all available GPUs are going to be used for
+  replication.  If no GPUs are available, then the model is going to be
+  placed on the CPU.
+
+  Two modes of local replication over available GPUs are supported:
+    1)  If exactly 1 GPU is detected, then variables and operations are placed
+        onto GPU.
+    2)  If more than 1 GPU is detected, then variables are going to be placed on
+        the CPU.  Replicas of operations are placed on each individual GPU.
+
+  Here is an example of how one might use their `model_fn` to run over GPUs:
+    ```python
+       def optimizer_fn():
+         return tf.train.GradientDescentOptimizer(learning_rate=0.001)
+       ...
+       def model_fn(...):  # See `model_fn` in `Estimator`.
+         loss = ...
+         if mode == tf.estimator.ModeKeys.TRAIN:
+           #  See the section below on `EstimatorSpec.train_op`.
+           return EstimatorSpec(mode=mode, loss=loss, train_op=tf.noop())
+
+         #  No change for `ModeKeys.EVAL` or `ModeKeys.PREDICT`.
+         return EstimatorSpec(...)
+       ...
+       classifier = tf.estimator.Estimator(
+         model_fn=replicate_model_fn.replicate_model_fn(model_fn, optimizer_fn))
+    ```
+
+  On `EstimatorSpec.train_op`:
+  `model_fn` returns `EstimatorSpec.train_op` for
+  `tf.estimator.GraphKeys.TRAIN`. It is typically derived using an optimizer.
+  `replicate_model_fn` ignores the returned `EstimatorSpec.train_op`, so there
+  is no need to use an optimizer inside the user's `model_fn`.  The
+  `EstimatorSpec.loss` subgraph is going to be executed, while
+  `EstimatorSpec.train_op` isn't going to be executed. One could pass
+  `train_op=tf.noop()` to `EstimatorSpec`.
+
+  On sharding input features and labels:
+  Input features and labels are split for consumption by each tower. They are
+  split across the dimension 0.  Features and labels need to be batch major.
+
+  On reduction algorithms:
+  Certain algorithms were chosen for aggregating results of computations on
+  multiple towers:
+    - Losses from all towers are reduced using sum.
+    - Gradients are reduced using sum for each trainable variable.
+    - `eval_metrics_ops` are reduced per metric using `reduce_mean`.
+    - `EstimatorSpec.predictions` and `EstimatorSpec.export_outputs` are
+      reduced using concatenation.
+    - For all other fields of `EstimatorSpec` the values of the first tower
+      are taken.
+
+  On replication of variables:
+  Variables are not duplicated between towers.  Instead, they are placed on a
+  single device as defined above and shared across towers.
+
+  Other current limitations:
+    - `predictions` are not supported for `ModeKeys.EVAL`.  That is required for
+      `tf.contrib.estimator.add_metrics`.
+
+  Args:
+    model_fn: `model_fn` as defined in `Estimator`.  See the section above about
+      the train_op argument of `EstimatorSpec`.
+    optimizer_fn: a function that returns an optimizer instance.  The function
+      may accept one `params` argument.  This is the `params` argument as
+      defined by `Estimator`.  See  the `Estimator` documentation for details.
+    devices: Optional list of devices to replicate the model across.  This
+      argument can be used to replice only on the subset of available GPUs.
+      If `None`, then all available GPUs are going to be used for replication.
+      If no GPUs are available, then the model is going to be placed on the CPU.
+
+  Returns:
+    A replicated version of the supplied `model_fn`. Returned function that
+      conforms to the requirements of `Estimator`'s `model_fn` and can be used
+      instead of the supplied `model_fn`.
+  """
+  if not devices:
+    devices = _get_local_devices('GPU') or _get_local_devices('CPU')
+
+  is_a_single_gpu_case = len(devices) == 1 and 'GPU' in devices[0]
+  local_ps_device = '/{}:0'.format('GPU' if is_a_single_gpu_case else 'CPU')
+
+  tf_logging.info('Replicating the `model_fn` across {}.  Local parameter '
+                  'server device is going to be {}.'.format(
+                      devices, local_ps_device))
+
+  def replicated_model_fn(mode, features, labels, params=None, config=None):
+    """Replicated version of `model_fn` to be used instead."""
+    feature_shards, label_shards = _split_batch(
+        features, labels, len(devices), device=local_ps_device)
+    tower_specs = _get_loss_towers(
+        model_fn=model_fn,
+        mode=mode,
+        features=feature_shards,
+        labels=label_shards,
+        params=params,
+        config=config,
+        devices=devices,
+        local_ps_device=local_ps_device)
+
+    if mode == model_fn_lib.ModeKeys.TRAIN:
+      train_op = _minimize_towers(tower_specs,
+                                  _call_optimizer_fn(optimizer_fn, params))
+      return _train_spec(
+          tower_specs, train_op, aggregation_device=local_ps_device)
+    elif mode == model_fn_lib.ModeKeys.EVAL:
+      return _eval_spec(tower_specs, aggregation_device=local_ps_device)
+    elif mode == model_fn_lib.ModeKeys.PREDICT:
+      return _predict_spec(tower_specs, aggregation_device=local_ps_device)
+
+  return replicated_model_fn
+
+
+def _get_local_devices(device_type):
+  local_device_protos = device_lib.list_local_devices()
+  return [
+      device.name
+      for device in local_device_protos
+      if device.device_type == device_type
+  ]
+
+
+def _split_batch(features, labels, number_of_shards, device):
+  """Split input features and labes into batches."""
+
+  def split_dictionary(dictionary):
+    shards = [{} for _ in range(number_of_shards)]
+    for name, tensor in six.iteritems(dictionary):
+      for i, shard in enumerate(array_ops.split(tensor, number_of_shards)):
+        shards[i][name] = shard
+    return shards
+
+  with ops_lib.name_scope('split_inputs'):
+    with ops_lib.device(device):
+      if isinstance(features, dict):
+        feature_shards = split_dictionary(features)
+      else:
+        feature_shards = array_ops.split(features, number_of_shards)
+
+      if labels is None:
+        label_shards = None
+      elif isinstance(labels, dict):
+        label_shards = split_dictionary(labels)
+      else:
+        label_shards = array_ops.split(labels, number_of_shards)
+  return feature_shards, label_shards
+
+
+_DEFAULT_NAME_SCOPE_PATTERN = 'tower_{}'
+
+
+def _get_loss_towers(model_fn,
+                     mode,
+                     features,
+                     labels,
+                     params,
+                     config,
+                     devices,
+                     local_ps_device,
+                     name_scope_pattern=_DEFAULT_NAME_SCOPE_PATTERN):
+  """Replicate the loss computation across devices."""
+  tower_specs = []
+
+  model_fn_args = util.fn_args(model_fn)
+  optional_params = {}
+  if 'params' in model_fn_args:
+    optional_params['params'] = copy.deepcopy(params)
+  if 'config' in model_fn_args:
+    optional_params['config'] = copy.deepcopy(config)
+
+  for i, device in enumerate(devices):
+    is_the_first_tower = (i == 0)
+
+    device_setter = _local_device_setter(
+        worker_device=device, ps_device=local_ps_device)
+
+    # We would like to preserve the names of the variables and ops that a user
+    # might be relying on. Names with prefix are going to resolve to variables
+    # and ops of the first tower.
+    name_scope = name_scope_pattern
+    if is_the_first_tower:
+      name_scope = ''
+
+    with variable_scope.variable_scope('', reuse=not is_the_first_tower):
+      with ops_lib.name_scope(name_scope.format(i)):
+        with ops_lib.device(device_setter):
+          labels_shard = None
+          if labels:
+            labels_shard = labels[i]
+
+          tower_specs.append(
+              model_fn(
+                  mode=mode,
+                  features=features[i],
+                  labels=labels_shard,
+                  **optional_params))
+  return tower_specs
+
+
+def _local_device_setter(ps_device, worker_device):
+  """A device setter that puts distributes Var/Ops to PS/workers."""
+  ps_ops = ['Variable', 'VariableV2', 'VarHandleOp']
+
+  def local_device_chooser(op):
+    current_device = framework_device.DeviceSpec.from_string(op.device or '')
+
+    node_def = op if isinstance(op, node_def_pb2.NodeDef) else op.node_def
+    if node_def.op in ps_ops:
+      ps_device_spec = framework_device.DeviceSpec.from_string(
+          '{}'.format(ps_device))
+
+      ps_device_spec.merge_from(current_device)
+      return ps_device_spec.to_string()
+    else:
+      worker_device_spec = framework_device.DeviceSpec.from_string(
+          worker_device or '')
+      worker_device_spec.merge_from(current_device)
+      return worker_device_spec.to_string()
+
+  return local_device_chooser
+
+
+def _minimize_towers(tower_specs, optimizer):
+  """Aggregate and apply gradients for computed losses."""
+  grad_lists = {}
+  for tower_spec in tower_specs:
+    with ops_lib.device(tower_spec.loss.device):
+      variables = variables_lib.trainable_variables()
+      gradients = gradients_lib.gradients(tower_spec.loss, variables)
+
+      for var, grad in zip(variables, gradients):
+        if grad is not None:
+          grad_lists.setdefault(var, []).append(grad)
+
+  aggregated_grads = []
+  with ops_lib.name_scope('gradient_aggregating'):
+    for var, grads in six.iteritems(grad_lists):
+      grad = _compute_sum_on_device(grads, var.device)
+      aggregated_grads.append((grad, var))
+
+  train_op = optimizer.apply_gradients(
+      aggregated_grads, global_step=training_util.get_global_step())
+
+  return train_op
+
+
+def _call_optimizer_fn(optimizer_fn, params):
+  arguments = {}
+  optimizer_fn_arguments = util.fn_args(optimizer_fn)
+  if 'params' in optimizer_fn_arguments:
+    arguments['params'] = params
+  return optimizer_fn(**arguments)
+
+
+def _compute_sum_on_device(values, device, name=None):
+  with ops_lib.device(device):
+    return math_ops.add_n(values, name=name)
+
+
+def _train_spec(tower_specs,
+                train_op,
+                aggregation_device,
+                aggregated_loss_name='loss'):
+  """Populate replicated EstimatorSpec for `GraphKeys.TRAIN`."""
+  estimator_spec = tower_specs[0]._asdict()
+  estimator_spec['mode'] = model_fn_lib.ModeKeys.TRAIN
+  estimator_spec['train_op'] = train_op
+  estimator_spec['loss'] = _compute_sum_on_device(
+      [spec.loss for spec in tower_specs], aggregation_device,
+      aggregated_loss_name)
+  return model_fn_lib.EstimatorSpec(**estimator_spec)
+
+
+def _eval_spec(tower_specs, aggregation_device, aggregated_loss_name='loss'):
+  """Populate replicated EstimatorSpec for `GraphKeys.EVAL`."""
+  estimator_spec = tower_specs[0]._asdict()
+  estimator_spec['mode'] = model_fn_lib.ModeKeys.EVAL
+  estimator_spec['loss'] = _compute_sum_on_device(
+      [spec.loss for spec in tower_specs], aggregation_device,
+      aggregated_loss_name)
+
+  eval_metric_ops_lists = {}
+  for tower_spec in tower_specs:
+    metrics = tower_spec.eval_metric_ops or {}
+    for name, (_, update_op) in six.iteritems(metrics):
+      update_ops = eval_metric_ops_lists.setdefault(name, ([]))
+      update_ops.append(update_op)
+
+  eval_metric_ops = {}
+  for name, (metric_tensor, _) in six.iteritems(tower_specs[0].eval_metric_ops):
+    with ops_lib.control_dependencies(eval_metric_ops_lists[name]):
+      # This operation reduces local variables across all metrics, yet is
+      # called for every metric.  This is redundant and it's done because
+      # it is hard to know what local variables correspond to what metric.
+      # Estimator is going to execute all `reduced_update_op`s as part of
+      # a group inside a single `Session.run()` call, which will avoid duplicate
+      # computation.
+      reduced_update_op = _reduce_metric_variables(len(tower_specs))
+    eval_metric_ops[name] = (metric_tensor, reduced_update_op)
+
+  estimator_spec['eval_metric_ops'] = eval_metric_ops
+  return model_fn_lib.EstimatorSpec(**estimator_spec)
+
+
+def _reduce_metric_variables(number_of_towers):
+  """Aggregate local variables used in metrics into the first tower."""
+  if number_of_towers == 1:
+    return control_flow_ops.no_op()
+
+  metric_variables = ops_lib.get_collection(ops_lib.GraphKeys.METRIC_VARIABLES)
+  variables_per_tower = len(metric_variables) // number_of_towers
+
+  if len(metric_variables) % number_of_towers != 0:
+    raise ValueError(
+        'Different `EstimatorSpec.eval_metric_ops` across `model_fn()` calls.'
+        ' Expected {} local variables, but got {} instead.'.format(
+            variables_per_tower * number_of_towers, len(metric_variables)))
+
+  # `metric_variables` has the size of `variables_per_tower` x
+  #  number_of_towers.  Each tower is produced by calling the same model_fn.
+  #  First `variables_per_tower` correspond to the first tower.  Each such
+  #  variable has an replica at the `(variables_per_tower * i)` position, where
+  #  `i` is `[1.. number_of_towers]`.  We are going to add values from replicas
+  #  to each variable of the first tower.  We then zero out replica values, so
+  #  that `_reduce_metric_variables` operation is idempotent.  If a metric
+  #  is then computed based on local variables from the first tower, then the
+  #  resulting metric is an estimate for all `number_of_towers` towers.
+  ops = []
+  for i in range(0, variables_per_tower):
+    next_replica_id = i + variables_per_tower
+    replicas = [
+        metric_variables[replica_id]
+        for replica_id in range(next_replica_id, len(metric_variables),
+                                variables_per_tower)
+    ]  #  `replicas` doesn't contain the first-tower variable.
+
+    reduce_op = state_ops.assign_add(metric_variables[i],
+                                     math_ops.add_n(replicas))
+
+    with ops_lib.control_dependencies([reduce_op]):
+      for replica in replicas:
+        zeros_for_replica = array_ops.zeros(
+            array_ops.shape(replica), dtype=replica.dtype)
+        zero_out_replica_op = state_ops.assign(replica, zeros_for_replica)
+        ops.append(zero_out_replica_op)
+
+  return control_flow_ops.group(*ops)
+
+
+def _predict_spec(tower_specs, aggregation_device):
+  """Populate replicated EstimatorSpec for `GraphKeys.PREDICT`."""
+  estimator_spec = tower_specs[0]._asdict()
+  estimator_spec['mode'] = model_fn_lib.ModeKeys.PREDICT
+
+  with ops_lib.device(aggregation_device):
+    estimator_spec['predictions'] = _concat_tensor_dicts(
+        *[tower_spec.predictions for tower_spec in tower_specs])
+
+    export_outputs_dict = _dict_concat(
+        *[tower_spec.export_outputs for tower_spec in tower_specs])
+
+    export_outputs = {}
+    for name, export_output_list in six.iteritems(export_outputs_dict):
+      if isinstance(export_output_list[0], export_output_lib.PredictOutput):
+        export_outputs[name] = export_output_lib.PredictOutput(
+            outputs=_concat_tensor_dicts(*[
+                export_output.outputs for export_output in export_output_list
+            ]))
+      elif isinstance(export_output_list[0],
+                      export_output_lib.RegressionOutput):
+        export_outputs[name] = export_output_lib.RegressionOutput(
+            value=array_ops.concat(
+                [export_output.value for export_output in export_output_list],
+                axis=0))
+      elif isinstance(export_output_list[0],
+                      export_output_lib.ClassificationOutput):
+        scores = None
+        if export_output_list[0].scores is not None:
+          scores = array_ops.concat(
+              [export_output.scores for export_output in export_output_list],
+              axis=0)
+
+        classes = None
+        if export_output_list[0].classes is not None:
+          classes = array_ops.stack(
+              [export_output.classes for export_output in export_output_list],
+              axis=0)
+
+        export_outputs[name] = export_output_lib.ClassificationOutput(
+            scores=scores, classes=classes)
+
+  estimator_spec['export_outputs'] = export_outputs
+  return model_fn_lib.EstimatorSpec(**estimator_spec)
+
+
+def _concat_tensor_dicts(*tensor_dicts):
+  return {
+      name: array_ops.concat(tensors, axis=0, name=name)
+      for name, tensors in six.iteritems(_dict_concat(*tensor_dicts))
+  }
+
+
+def _dict_concat(*dicts):
+  list_dict = {}
+  for d in dicts:
+    if d is None:
+      continue
+
+    for k, v in six.iteritems(d):
+      list_dict.setdefault(k, []).append(v)
+  return list_dict
diff --git a/tensorflow/contrib/estimator/python/estimator/replicate_model_fn_test.py b/tensorflow/contrib/estimator/python/estimator/replicate_model_fn_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..10b47fba5af0f2a036df637a4f4f996d388270c6
--- /dev/null
+++ b/tensorflow/contrib/estimator/python/estimator/replicate_model_fn_test.py
@@ -0,0 +1,901 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for utilities that replicate `Estimator.model_fn` over GPUs."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import re
+import shutil
+import tempfile
+import numpy as np
+import six
+
+from tensorflow.contrib.estimator.python.estimator import replicate_model_fn
+from tensorflow.python.estimator import estimator as estimator_lib
+from tensorflow.python.estimator import model_fn as model_fn_lib
+from tensorflow.python.estimator.canned import dnn
+from tensorflow.python.estimator.canned import optimizers
+from tensorflow.python.estimator.canned import prediction_keys
+from tensorflow.python.estimator.export import export
+from tensorflow.python.estimator.export import export_output
+from tensorflow.python.estimator.inputs import numpy_io
+from tensorflow.python.feature_column import feature_column
+from tensorflow.python.framework import constant_op
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops as ops_lib
+from tensorflow.python.framework import test_util
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import control_flow_ops
+from tensorflow.python.ops import math_ops
+from tensorflow.python.ops import metrics as metrics_lib
+from tensorflow.python.ops import variable_scope
+from tensorflow.python.ops import variables
+from tensorflow.python.ops.losses import losses
+from tensorflow.python.platform import gfile
+from tensorflow.python.platform import test
+from tensorflow.python.saved_model import signature_constants
+from tensorflow.python.summary.writer import writer_cache
+from tensorflow.python.training import gradient_descent
+
+
+class DNNClassifierIntegrationTest(test_util.TensorFlowTestCase):
+
+  def setUp(self):
+    self._model_dir = tempfile.mkdtemp()
+
+  def test_complete_flow(self):
+    n_classes = 3
+    input_dimension = 2
+    batch_size = 12
+
+    data = np.linspace(
+        0., n_classes - 1., batch_size * input_dimension, dtype=np.float32)
+    x_data = data.reshape(batch_size, input_dimension)
+    y_data = np.reshape(self._as_label(data[:batch_size]), (batch_size, 1))
+    train_input_fn = numpy_io.numpy_input_fn(
+        x={'x': x_data},
+        y=y_data,
+        batch_size=batch_size,
+        num_epochs=None,
+        shuffle=True)
+    eval_input_fn = numpy_io.numpy_input_fn(
+        x={'x': x_data}, y=y_data, batch_size=batch_size, shuffle=False)
+    predict_input_fn = numpy_io.numpy_input_fn(
+        x={'x': x_data}, batch_size=batch_size, shuffle=False)
+
+    feature_columns = [
+        feature_column.numeric_column('x', shape=(input_dimension,))
+    ]
+
+    estimator = dnn.DNNClassifier(
+        hidden_units=(2, 2),
+        feature_columns=feature_columns,
+        n_classes=n_classes,
+        model_dir=self._model_dir)
+
+    def optimizer_fn():
+      return optimizers.get_optimizer_instance('Adagrad', learning_rate=0.05)
+
+    # TODO(isaprykin):  Switch Estimator to use allow_soft_placement=True
+    # during export_savedmodel and then switch this test to replicate over
+    # GPUs instead of CPUs.
+    estimator = estimator_lib.Estimator(
+        model_fn=replicate_model_fn.replicate_model_fn(
+            estimator.model_fn,
+            optimizer_fn,
+            devices=['/cpu:0', '/cpu:0', '/cpu:0']),
+        model_dir=estimator.model_dir,
+        config=estimator.config,
+        params=estimator.params)
+
+    num_steps = 10
+    estimator.train(train_input_fn, steps=num_steps)
+
+    scores = estimator.evaluate(eval_input_fn)
+    self.assertEqual(num_steps, scores[ops_lib.GraphKeys.GLOBAL_STEP])
+    self.assertIn('loss', six.iterkeys(scores))
+
+    predicted_proba = np.array([
+        x[prediction_keys.PredictionKeys.PROBABILITIES]
+        for x in estimator.predict(predict_input_fn)
+    ])
+    self.assertAllEqual((batch_size, n_classes), predicted_proba.shape)
+
+    feature_spec = feature_column.make_parse_example_spec(feature_columns)
+    serving_input_receiver_fn = export.build_parsing_serving_input_receiver_fn(
+        feature_spec)
+    export_dir = estimator.export_savedmodel(tempfile.mkdtemp(),
+                                             serving_input_receiver_fn)
+    self.assertTrue(gfile.Exists(export_dir))
+
+  def _as_label(self, data_in_float):
+    return np.rint(data_in_float).astype(np.int64)
+
+  def tearDown(self):
+    if self._model_dir:
+      writer_cache.FileWriterCache.clear()
+      shutil.rmtree(self._model_dir)
+
+
+class ReplicateModelTest(test_util.TensorFlowTestCase):
+
+  def model_fn(self, mode, features, labels, params):
+    c = variable_scope.get_variable(
+        'c',
+        initializer=constant_op.constant(10, dtype=dtypes.float64),
+        dtype=dtypes.float64)
+
+    predictions = math_ops.multiply(features, c)
+
+    loss = None
+    if mode is not model_fn_lib.ModeKeys.PREDICT:
+      loss = losses.absolute_difference(
+          labels=labels,
+          predictions=predictions,
+          reduction=losses.Reduction.SUM)
+      loss = math_ops.reduce_sum(loss)
+
+    metrics = {
+        'accuracy': metrics_lib.accuracy(labels, predictions),
+        'auc': metrics_lib.auc(labels, predictions)
+    }
+
+    return model_fn_lib.EstimatorSpec(
+        mode=mode,
+        loss=loss,
+        eval_metric_ops=metrics,
+        predictions={'probabilities': predictions},
+        train_op=control_flow_ops.no_op())  # This train_op isn't actually used.
+
+  def optimizer_fn(self, params):
+    return gradient_descent.GradientDescentOptimizer(params['learning_rate'])
+
+  @property
+  def params(self):
+    params = {}
+    params['learning_rate'] = 1.0
+    return params
+
+  def test_train(self):
+    features = np.array([[1.0], [2.0]])
+    labels = np.array([[1.0], [2.0]])
+
+    with self.test_session() as session:
+      replicated_model_fn = replicate_model_fn.replicate_model_fn(
+          self.model_fn, self.optimizer_fn, devices=['/gpu:0', '/gpu:1'])
+      estimator_spec = replicated_model_fn(model_fn_lib.ModeKeys.TRAIN,
+                                           features, labels, self.params)
+      session.run(variables.global_variables_initializer())
+
+      # loss = feature * c - label
+      total_loss = (1.0 * 10 - 1.0) + (2.0 * 10 - 2.0)
+      self.assertEqual(total_loss, session.run(estimator_spec.loss))
+
+      # loss' of c is 3.
+      # new value of c = 10 - learning rate * 3 = 7.0.
+      session.run(estimator_spec.train_op)
+      with variable_scope.variable_scope('', reuse=True):
+        c = variable_scope.get_variable('c', dtype=dtypes.float64)
+        self.assertEqual(7.0, session.run(c))
+
+  def test_train_spec_with_optimizer_without_params(self):
+
+    def optimizer_fn_without_params():
+      return gradient_descent.GradientDescentOptimizer(learning_rate=1.0)
+
+    features = np.array([[1.0], [2.0]])
+    labels = np.array([[1.0], [2.0]])
+
+    with self.test_session() as session:  # pylint: disable=unused-variable
+      replicated_model_fn = replicate_model_fn.replicate_model_fn(
+          self.model_fn,
+          optimizer_fn_without_params,
+          devices=['/gpu:0', '/gpu:1'])
+      # This call is going to fail if `replicated_model_fn` is still passing
+      # `params` inside `optimizer_fn`, even though the latter doesn't take any:
+      estimator_spec = replicated_model_fn(model_fn_lib.ModeKeys.TRAIN,
+                                           features, labels, self.params)
+      del estimator_spec
+
+  def test_eval(self):
+    features = np.array([[0.01], [0.002]])
+    labels = np.array([[0.01], [0.02]])
+
+    with self.test_session() as session:
+      replicated_model_fn = replicate_model_fn.replicate_model_fn(
+          self.model_fn, self.optimizer_fn, devices=['/gpu:0', '/gpu:1'])
+      estimator_spec = replicated_model_fn(model_fn_lib.ModeKeys.EVAL, features,
+                                           labels, self.params)
+      session.run(variables.local_variables_initializer())
+      session.run(variables.global_variables_initializer())
+
+      accuracy, a = estimator_spec.eval_metric_ops['accuracy']
+      auc, b = estimator_spec.eval_metric_ops['auc']
+
+      session.run([a, b])
+      accuracy = session.run(accuracy)
+      auc = session.run(auc)
+
+      # Accuracy is 0.0 (no match) in the first tower.
+      # Accuracy is 1.0 (match) in the second tower, since the feature
+      # times weight "c" happened to be equal to the label.
+      total_loss = ((0.01 * 10 - 0.01) + (0.002 * 10 - 0.02))
+
+      self.assertNear((0.0 + 1.0) / 2.0, accuracy, 0.01)
+      self.assertEqual(0, auc)
+      self.assertNear(total_loss, session.run(estimator_spec.loss), 0.01)
+
+  def test_predict(self):
+    features = np.array([[0.01], [0.002]])
+    labels = np.array([[0.01], [0.02]])
+
+    with self.test_session() as session:
+      replicated_model_fn = replicate_model_fn.replicate_model_fn(
+          self.model_fn, self.optimizer_fn, devices=['/gpu:0', '/gpu:1'])
+      estimator_spec = replicated_model_fn(model_fn_lib.ModeKeys.PREDICT,
+                                           features, labels, self.params)
+      session.run(variables.global_variables_initializer())
+
+      self.assertAllClose({
+          'probabilities': np.array([[0.1], [0.02]])
+      }, session.run(estimator_spec.predictions))
+
+  def test_train_single_tower(self):
+    features = np.array([[1.0], [2.0]])
+    labels = np.array([[1.0], [2.0]])
+
+    with self.test_session() as session:
+      replicated_model_fn = replicate_model_fn.replicate_model_fn(
+          self.model_fn, self.optimizer_fn)
+      estimator_spec = replicated_model_fn(model_fn_lib.ModeKeys.TRAIN,
+                                           features, labels, self.params)
+      session.run(variables.global_variables_initializer())
+
+      # loss = feature * c - label
+      total_loss = (1.0 * 10 - 1.0) + (2.0 * 10 - 2.0)
+      self.assertEqual(total_loss, session.run(estimator_spec.loss))
+
+      # loss' of c is 3.
+      # new value of c = 10 - learning rate * 3 = 7.0.
+      session.run(estimator_spec.train_op)
+      with variable_scope.variable_scope('', reuse=True):
+        c = variable_scope.get_variable('c', dtype=dtypes.float64)
+        self.assertEqual(7.0, session.run(c))
+
+  def test_eval_single_tower(self):
+    features = np.array([[0.01], [0.002]])
+    labels = np.array([[0.01], [0.02]])
+
+    with self.test_session() as session:
+      replicated_model_fn = replicate_model_fn.replicate_model_fn(
+          self.model_fn, self.optimizer_fn, devices=['/gpu:0'])
+      estimator_spec = replicated_model_fn(model_fn_lib.ModeKeys.EVAL, features,
+                                           labels, self.params)
+      session.run(variables.local_variables_initializer())
+      session.run(variables.global_variables_initializer())
+
+      accuracy, a = estimator_spec.eval_metric_ops['accuracy']
+      auc, b = estimator_spec.eval_metric_ops['auc']
+
+      session.run([a, b])
+      accuracy = session.run(accuracy)
+      auc = session.run(auc)
+
+      # Accuracy is 0.0 (no match) in the first tower.
+      # Accuracy is 1.0 (match) in the second tower, since the feature
+      # times weight "c" happened to be equal to the label.
+      total_loss = ((0.01 * 10 - 0.01) + (0.002 * 10 - 0.02))
+
+      self.assertNear((0.0 + 1.0) / 2.0, accuracy, 0.01)
+      self.assertEqual(0, auc)
+      self.assertNear(total_loss, session.run(estimator_spec.loss), 0.01)
+
+  def test_predict_single_tower(self):
+    features = np.array([[0.01], [0.002]])
+    labels = np.array([[0.01], [0.02]])
+
+    with self.test_session() as session:
+      replicated_model_fn = replicate_model_fn.replicate_model_fn(
+          self.model_fn, self.optimizer_fn, devices=['/gpu:0'])
+      estimator_spec = replicated_model_fn(model_fn_lib.ModeKeys.PREDICT,
+                                           features, labels, self.params)
+      session.run(variables.global_variables_initializer())
+
+      self.assertAllClose({
+          'probabilities': np.array([[0.1], [0.02]])
+      }, session.run(estimator_spec.predictions))
+
+
+class GetLossTowersTest(test_util.TensorFlowTestCase):
+
+  def model_fn(self, mode, features, labels, params):
+    c = variable_scope.get_variable(
+        'c',
+        initializer=constant_op.constant(0.25, dtype=dtypes.float64),
+        dtype=dtypes.float64)
+
+    predictions = math_ops.add(np.array([0.1, 0.2, 0.3, features[0]]), c)
+    labels = np.array([0.1, 0.2, 0.3, labels[0]])
+
+    loss = losses.absolute_difference(
+        labels=labels, predictions=predictions, reduction=losses.Reduction.SUM)
+
+    return model_fn_lib.EstimatorSpec(mode=mode, loss=math_ops.reduce_sum(loss))
+
+  def test_gradients_are_computed(self):
+    with self.test_session() as session:
+      tower_specs = replicate_model_fn._get_loss_towers(
+          self.model_fn,
+          mode=None,
+          features=[[0.6], [1.6]],
+          labels=[[0.6], [0.6]],
+          params=None,
+          config=None,
+          devices=['/gpu:0', '/gpu:1'],
+          local_ps_device='/gpu:0',
+          name_scope_pattern='test_tower_{}')
+      session.run(variables.global_variables_initializer())
+
+      self.assertEqual(len(tower_specs), 2)
+
+      self.assertEqual('/device:GPU:0', tower_specs[0].loss.device)
+      self.assertEqual('Sum:0', tower_specs[0].loss.name)
+      self.assertEqual(1.0, session.run(tower_specs[0].loss))
+
+      self.assertEqual('/device:GPU:1', tower_specs[1].loss.device)
+      self.assertEqual('test_tower_1/Sum:0', tower_specs[1].loss.name)
+      # The input batch for the second tower had a loss that is 1.0
+      # bigger: 0.6 vs 1.6.
+      self.assertEqual(2.0, session.run(tower_specs[1].loss))
+
+      self.assertEqual(1, len(variables.global_variables()))
+      self.assertEqual(1, len(variables.trainable_variables()))
+
+      with variable_scope.variable_scope('', reuse=True):
+        c = variable_scope.get_variable('c', dtype=dtypes.float64)
+        self.assertEqual(0.25, session.run(c))
+
+
+class SplitBatchTest(test_util.TensorFlowTestCase):
+
+  def evaluate_shards(self, first_list, second_list):
+    evaluate_items = lambda x: x.eval()
+    return list(map(evaluate_items, first_list)), list(
+        map(evaluate_items, second_list))
+
+  def test_simple_half_split(self):
+    with self.test_session() as session:  # pylint: disable=unused-variable
+      features = [0.0, 1.0, 2.0, 3.0]
+      labels = [10.0, 11.0, 12.0, 13.0]
+      feature_shards, label_shards = replicate_model_fn._split_batch(
+          features, labels, 2, device='/gpu:0')
+
+      feature_shards, label_shards = self.evaluate_shards(
+          feature_shards, label_shards)
+
+      self.assertAllEqual([[0.0, 1.0], [2.0, 3.0]], feature_shards)
+      self.assertAllEqual([[10.0, 11.0], [12.0, 13.0]], label_shards)
+
+  def test_to_each_their_own(self):
+    with self.test_session() as session:  # pylint: disable=unused-variable
+      features = [0.0, 1.0, 2.0, 3.0]
+      labels = [10.0, 11.0, 12.0, 13.0]
+      feature_shards, label_shards = replicate_model_fn._split_batch(
+          features, labels, 4, device='/gpu:0')
+
+      feature_shards, label_shards = self.evaluate_shards(
+          feature_shards, label_shards)
+
+      self.assertAllEqual([[0.0], [1.0], [2.0], [3.0]], feature_shards)
+      self.assertAllEqual([[10.0], [11.0], [12.0], [13.0]], label_shards)
+
+  def test_one_batch(self):
+    with self.test_session() as session:  # pylint: disable=unused-variable
+      features = [0.0, 1.0, 2.0, 3.0]
+      labels = [10.0, 11.0, 12.0, 13.0]
+      feature_shards, label_shards = replicate_model_fn._split_batch(
+          features, labels, 1, device='/gpu:0')
+
+      feature_shards, label_shards = self.evaluate_shards(
+          feature_shards, label_shards)
+
+      self.assertAllEqual([[0.0, 1.0, 2.0, 3.0]], feature_shards)
+      self.assertAllEqual([[10.0, 11.0, 12.0, 13.0]], label_shards)
+
+  def test_half_split_in_dictionary(self):
+    with self.test_session() as session:  # pylint: disable=unused-variable
+      features = {'first': [0.0, 1.0, 2.0, 3.0], 'second': [4.0, 5.0, 6.0, 7.0]}
+      labels = [10.0, 11.0, 12.0, 13.0]
+
+      feature_shards, label_shards = replicate_model_fn._split_batch(
+          features, labels, 2, device='/gpu:0')
+
+      self.assertAllEqual([0.0, 1.0], feature_shards[0]['first'].eval())
+      self.assertAllEqual([4.0, 5.0], feature_shards[0]['second'].eval())
+      self.assertAllEqual([2.0, 3.0], feature_shards[1]['first'].eval())
+      self.assertAllEqual([6.0, 7.0], feature_shards[1]['second'].eval())
+      self.assertAllEqual([10.0, 11.0], label_shards[0].eval())
+      self.assertAllEqual([12.0, 13.0], label_shards[1].eval())
+
+  def test_one_batch_in_dictionary(self):
+    with self.test_session() as session:  # pylint: disable=unused-variable
+      features = {'first': [0.0, 1.0, 2.0, 3.0], 'second': [4.0, 5.0, 6.0, 7.0]}
+      labels = [10.0, 11.0, 12.0, 13.0]
+
+      feature_shards, label_shards = replicate_model_fn._split_batch(
+          features, labels, 1, device='/gpu:0')
+
+      self.assertAllEqual([0.0, 1.0, 2.0, 3.0],
+                          feature_shards[0]['first'].eval())
+      self.assertAllEqual([4.0, 5.0, 6.0, 7.0],
+                          feature_shards[0]['second'].eval())
+      self.assertAllEqual([10.0, 11.0, 12.0, 13.0], label_shards[0].eval())
+
+  def test_feature_and_label_dictionaries(self):
+    with self.test_session() as session:  # pylint: disable=unused-variable
+      features = {'first': [0.0, 1.0, 2.0, 3.0], 'second': [4.0, 5.0, 6.0, 7.0]}
+      labels = {'first': [10.0, 11.0], 'second': [12.0, 13.0]}
+
+      feature_shards, label_shards = replicate_model_fn._split_batch(
+          features, labels, 2, device='/gpu:0')
+
+      self.assertAllEqual([0.0, 1.0], feature_shards[0]['first'].eval())
+      self.assertAllEqual([4.0, 5.0], feature_shards[0]['second'].eval())
+      self.assertAllEqual([2.0, 3.0], feature_shards[1]['first'].eval())
+      self.assertAllEqual([6.0, 7.0], feature_shards[1]['second'].eval())
+      self.assertAllEqual([10.0], label_shards[0]['first'].eval())
+      self.assertAllEqual([12.0], label_shards[0]['second'].eval())
+      self.assertAllEqual([11], label_shards[1]['first'].eval())
+      self.assertAllEqual([13.0], label_shards[1]['second'].eval())
+
+
+class TrainSpecTest(test_util.TensorFlowTestCase):
+
+  expected_predictions = {}
+
+  def create_estimator_spec(self, loss):
+    return model_fn_lib.EstimatorSpec(
+        mode=model_fn_lib.ModeKeys.TRAIN,
+        loss=loss,
+        train_op=loss,  # Not used; currently required.
+        predictions=self.expected_predictions)
+
+  def create_constant_loss(self, loss_value):
+    return constant_op.constant(loss_value, dtype=dtypes.float64)
+
+  def test_example(self):
+    with self.test_session() as session:
+      tower_losses = list(map(self.create_constant_loss, [2, 4, 6]))
+      tower_specs = list(map(self.create_estimator_spec, tower_losses))
+
+      expected_train_op = tower_losses[1]
+
+      estimator_spec = replicate_model_fn._train_spec(
+          tower_specs, expected_train_op, aggregation_device='/gpu:0')
+
+      self.assertEqual(expected_train_op, estimator_spec.train_op)
+      self.assertEqual(2 + 4 + 6, session.run(estimator_spec.loss))
+      self.assertEqual(self.expected_predictions, estimator_spec.predictions)
+
+
+class EvalSpecTest(test_util.TensorFlowTestCase):
+
+  def create_estimator_spec(self, loss, metrics):
+    return model_fn_lib.EstimatorSpec(
+        mode=model_fn_lib.ModeKeys.EVAL, loss=loss, eval_metric_ops=metrics)
+
+  def create_constant_loss(self, loss_value):
+    return constant_op.constant(loss_value, dtype=dtypes.float64)
+
+  def create_eval_metrics(self, noise):
+    predictions = np.array([0.1, 0.2, 0.3, 0.6 + noise])
+    labels = np.array([0.1, 0.2, 0.3, 0.6])
+
+    metrics = {
+        'accuracy': metrics_lib.accuracy(labels, predictions),
+        'auc': metrics_lib.auc(labels, predictions)
+    }
+    return metrics
+
+  def test_example(self):
+    with self.test_session() as session:
+      tower_losses = map(self.create_constant_loss, [2, 4, 6])
+      tower_metrics = map(self.create_eval_metrics, [0, 0.2, 0.3])
+      tower_specs = [
+          self.create_estimator_spec(l, m)
+          for l, m in zip(tower_losses, tower_metrics)
+      ]
+      session.run(variables.local_variables_initializer())
+
+      estimator_spec = replicate_model_fn._eval_spec(
+          tower_specs, aggregation_device='/device:GPU:0')
+
+      accuracy, a = estimator_spec.eval_metric_ops['accuracy']
+      auc, b = estimator_spec.eval_metric_ops['auc']
+
+      self.assertEqual('/device:CPU:0', accuracy.device)
+      self.assertEqual('/device:CPU:0', auc.device)
+
+      session.run([a, b])
+      accuracy = session.run(accuracy)
+      auc = session.run(auc)
+
+      self.assertNear((12 - 2) / 12, accuracy, 0.01)
+      self.assertEqual(0, auc)
+      self.assertEqual(2 + 4 + 6, session.run(estimator_spec.loss))
+
+  def test_handles_single_tower(self):
+    with self.test_session() as session:
+      tower_losses = map(self.create_constant_loss, [5])
+      tower_metrics = map(self.create_eval_metrics, [0.2])
+      tower_specs = [
+          self.create_estimator_spec(l, m)
+          for l, m in zip(tower_losses, tower_metrics)
+      ]
+      session.run(variables.local_variables_initializer())
+
+      estimator_spec = replicate_model_fn._eval_spec(
+          tower_specs, aggregation_device='/device:GPU:0')
+
+      accuracy, a = estimator_spec.eval_metric_ops['accuracy']
+      auc, b = estimator_spec.eval_metric_ops['auc']
+
+      self.assertEqual('/device:CPU:0', accuracy.device)
+      self.assertEqual('/device:CPU:0', auc.device)
+
+      session.run([a, b])
+      accuracy = session.run(accuracy)
+      auc = session.run(auc)
+
+      self.assertNear((4 - 1) / 4, accuracy, 0.01)
+      self.assertEqual(0, auc)
+      self.assertEqual(5, session.run(estimator_spec.loss))
+
+
+class PredictSpecTest(test_util.TensorFlowTestCase):
+
+  def model_fn(self, mode, features, labels, params):
+    c = variable_scope.get_variable(
+        'c',
+        initializer=constant_op.constant(0.25, dtype=dtypes.float64),
+        dtype=dtypes.float64)
+
+    predictions = math_ops.add(np.array([features[0], features[0]]), c)
+
+    return model_fn_lib.EstimatorSpec(
+        mode=model_fn_lib.ModeKeys.PREDICT,
+        predictions={
+            'probabilities': predictions
+        })
+
+  def test_example(self):
+    with self.test_session() as session:
+      tower_specs = replicate_model_fn._get_loss_towers(
+          self.model_fn,
+          mode=None,
+          features=[[0.1], [0.2]],
+          labels=[[], []],
+          params=None,
+          config=None,
+          devices=['/gpu:0', '/gpu:1'],
+          local_ps_device='/gpu:0',
+      )
+      session.run(variables.global_variables_initializer())
+
+      estimator_spec = replicate_model_fn._predict_spec(
+          tower_specs, aggregation_device='/gpu:0')
+
+      self.assertEqual('/device:GPU:0',
+                       estimator_spec.predictions['probabilities'].device)
+      self.assertAllClose({
+          'probabilities': np.array([0.35, 0.35, 0.45, 0.45])
+      }, session.run(estimator_spec.predictions))
+
+
+class ReduceMetricVariablesTest(test_util.TensorFlowTestCase):
+
+  def create_metric_variable(self, initial_value, name):
+    return variable_scope.variable(
+        initial_value,
+        trainable=False,
+        collections=[ops_lib.GraphKeys.METRIC_VARIABLES],
+        validate_shape=True,
+        name=name)
+
+  def create_tower_metrics(self, tower_id):
+    with variable_scope.variable_scope('', reuse=(tower_id != 0)):
+      self.create_metric_variable(1.3 * (tower_id + 1), 'total')
+      self.create_metric_variable(2.3 * (tower_id + 1), 'count')
+      self.create_metric_variable(
+          np.array([3.3, 3.5, 3.7]) * (tower_id + 1), 'total')
+
+  def test_example(self):
+    with self.test_session() as session:
+      for tower_id in range(3):
+        self.create_tower_metrics(tower_id)
+
+      session.run(
+          variables.variables_initializer(
+              ops_lib.get_collection(ops_lib.GraphKeys.METRIC_VARIABLES)))
+
+      session.run(
+          replicate_model_fn._reduce_metric_variables(number_of_towers=3))
+
+      # 1st tower = 1.3, 2.3,  [3.3, 3.5, 3.7]
+      # 2nd tower = 2.6, 4.6,  [6.6, 7.0, 7.4]
+      # 3rd tower = 3.9, 6.9,  [9.9, 10.5, 11.1]
+      # Reduced =   7.8, 13.8, [19.8, 21.0, 22.2]
+      # Towers are accumulated in the first tower.
+      local_metrics = session.run(
+          ops_lib.get_collection(ops_lib.GraphKeys.METRIC_VARIABLES))
+
+      self.assertNear(7.8, local_metrics[0], 0.01)
+      self.assertNear(13.8, local_metrics[1], 0.01)
+      self.assertAllClose([19.8, 21., 22.1], local_metrics[2], 0.01)
+      self.assertNear(0.0, local_metrics[3], 0.01)
+      self.assertNear(0.0, local_metrics[4], 0.01)
+      self.assertAllClose([0.0, 0.0, 0.0], local_metrics[5], 0.01)
+      self.assertNear(0.0, local_metrics[6], 0.01)
+      self.assertNear(0.0, local_metrics[7], 0.01)
+      self.assertAllClose([0.0, 0.0, 0.0], local_metrics[8], 0.01)
+
+  def test_reduce_is_idempotent(self):
+    with self.test_session() as session:
+      for tower_id in range(3):
+        self.create_tower_metrics(tower_id)
+
+      session.run(
+          variables.variables_initializer(
+              ops_lib.get_collection(ops_lib.GraphKeys.METRIC_VARIABLES)))
+
+      for _ in range(20):
+        session.run(
+            replicate_model_fn._reduce_metric_variables(number_of_towers=3))
+
+      local_metrics = session.run(
+          ops_lib.get_collection(ops_lib.GraphKeys.METRIC_VARIABLES))
+
+      self.assertNear(7.8, local_metrics[0], 0.01)
+      self.assertNear(13.8, local_metrics[1], 0.01)
+      self.assertAllClose([19.8, 21., 22.1], local_metrics[2], 0.01)
+      self.assertNear(0.0, local_metrics[3], 0.01)
+      self.assertNear(0.0, local_metrics[4], 0.01)
+      self.assertAllClose([0.0, 0.0, 0.0], local_metrics[5], 0.01)
+      self.assertNear(0.0, local_metrics[6], 0.01)
+      self.assertNear(0.0, local_metrics[7], 0.01)
+      self.assertAllClose([0.0, 0.0, 0.0], local_metrics[8], 0.01)
+
+  def test_handles_single_tower(self):
+    with self.test_session() as session:
+      self.create_tower_metrics(0)
+      session.run(
+          variables.variables_initializer(
+              ops_lib.get_collection(ops_lib.GraphKeys.METRIC_VARIABLES)))
+
+      session.run(
+          replicate_model_fn._reduce_metric_variables(number_of_towers=1))
+
+      local_metrics = session.run(
+          ops_lib.get_collection(ops_lib.GraphKeys.METRIC_VARIABLES))
+
+      self.assertNear(1.3, local_metrics[0], 0.01)
+      self.assertNear(2.3, local_metrics[1], 0.01)
+      self.assertAllClose([3.3, 3.5, 3.7], local_metrics[2], 0.01)
+
+  def test_doesnt_accept_uneven_number_of_variables(self):
+    with self.test_session() as session:
+      for tower_id in range(3):
+        self.create_tower_metrics(tower_id)
+      self.create_metric_variable(-1.0, 'oddball')
+
+      session.run(
+          variables.variables_initializer(
+              ops_lib.get_collection(ops_lib.GraphKeys.METRIC_VARIABLES)))
+
+      with self.assertRaisesRegexp(ValueError, ''):
+        session.run(
+            replicate_model_fn._reduce_metric_variables(number_of_towers=3))
+
+
+class MergeExportOutputsTest(test_util.TensorFlowTestCase):
+
+  def optimizer_fn(self):
+    return gradient_descent.GradientDescentOptimizer(1.0)
+
+  def model_fn(self, mode, features, labels, params):
+    c = variable_scope.get_variable(
+        'c',
+        initializer=constant_op.constant(10, dtype=dtypes.float64),
+        dtype=dtypes.float64)
+
+    predictions = {'probabilities': math_ops.multiply(features, c)}
+    loss = losses.absolute_difference(
+        labels=labels,
+        predictions=predictions['probabilities'],
+        reduction=losses.Reduction.SUM)
+
+    metrics = {
+        'accuracy': metrics_lib.accuracy(labels, predictions['probabilities']),
+        'auc': metrics_lib.auc(labels, predictions['probabilities'])
+    }
+    tensor_string_repr = str(features)
+    classes = constant_op.constant(
+        re.search('(split_inputs/split:[0-9])', tensor_string_repr).group(1),
+        dtype=dtypes.string)
+
+    export_outputs = {
+        signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY:
+            export_output.PredictOutput(predictions),
+        'classification_output':
+            export_output.ClassificationOutput(predictions['probabilities'],
+                                               classes),
+        'classification_scores':
+            export_output.ClassificationOutput(
+                scores=predictions['probabilities']),
+        'classification_classes':
+            export_output.ClassificationOutput(classes=classes),
+        'regression_output':
+            export_output.RegressionOutput(predictions['probabilities']),
+    }
+
+    return model_fn_lib.EstimatorSpec(
+        mode=mode,
+        loss=math_ops.reduce_sum(loss),
+        eval_metric_ops=metrics,
+        predictions=predictions,
+        train_op=loss,  # This train_op isn't actually used.
+        export_outputs=export_outputs)
+
+  def replicate_estimator_spec(self, session):
+    features = np.array([0.01, 0.002])
+    labels = np.array([0.01, 0.02])
+
+    replicated_model_fn = replicate_model_fn.replicate_model_fn(
+        self.model_fn, self.optimizer_fn, devices=['/gpu:0', '/gpu:1'])
+    estimator_spec = replicated_model_fn(model_fn_lib.ModeKeys.PREDICT,
+                                         features, labels, {})
+    session.run(variables.global_variables_initializer())
+    return estimator_spec
+
+  def test_merde_predict_output(self):
+    with self.test_session() as session:
+      estimator_spec = self.replicate_estimator_spec(session)
+      self.assertAllClose(
+          {
+              'probabilities': np.array([0.1, 0.02])
+          },
+          session.run(estimator_spec.export_outputs[
+              signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY].outputs))
+
+  def test_merge_classification_output_scores_classes(self):
+    with self.test_session() as session:
+      estimator_spec = self.replicate_estimator_spec(session)
+      self.assertAllClose(
+          [0.1, 0.02],
+          session.run(
+              estimator_spec.export_outputs['classification_output'].scores))
+      self.assertAllEqual(
+          [b'split_inputs/split:0', b'split_inputs/split:1'],
+          session.run(
+              estimator_spec.export_outputs['classification_output'].classes))
+
+  def test_merge_classification_output_scores(self):
+    with self.test_session() as session:
+      estimator_spec = self.replicate_estimator_spec(session)
+      self.assertAllClose(
+          [0.1, 0.02],
+          session.run(
+              estimator_spec.export_outputs['classification_scores'].scores))
+      self.assertEqual(
+          None, estimator_spec.export_outputs['classification_scores'].classes)
+
+  def test_merge_classification_output_classes(self):
+    with self.test_session() as session:
+      estimator_spec = self.replicate_estimator_spec(session)
+      self.assertAllEqual(
+          [b'split_inputs/split:0', b'split_inputs/split:1'],
+          session.run(
+              estimator_spec.export_outputs['classification_classes'].classes))
+      self.assertEqual(
+          None, estimator_spec.export_outputs['classification_classes'].scores)
+
+  def test_merge_regression_output(self):
+    with self.test_session() as session:
+      estimator_spec = self.replicate_estimator_spec(session)
+      self.assertAllClose(
+          [0.1, 0.02],
+          session.run(estimator_spec.export_outputs['regression_output'].value))
+
+
+class GetLocalDevicesTest(test_util.TensorFlowTestCase):
+
+  def test_there_is_at_least_a_cpu(self):
+    self.assertTrue(replicate_model_fn._get_local_devices('CPU'))
+
+  def test_there_is_no_xpu(self):
+    self.assertFalse(
+        replicate_model_fn._get_local_devices('XPU'))  # XPU doesn't exist.
+
+  def test_whether_there_is_a_gpu(self):
+    self.assertEqual(
+        len(replicate_model_fn._get_local_devices('GPU')),
+        test.is_gpu_available())
+
+
+class LocalDeviceSetterTest(test_util.TensorFlowTestCase):
+
+  def test_vars_are_on_ps_but_ops_are_on_workers(self):
+    local_device_setter = replicate_model_fn._local_device_setter(
+        ps_device='/device:GPU:3', worker_device='/device:GPU:2')
+
+    with ops_lib.device(local_device_setter):
+      c = variables.Variable(0.01)
+      self.assertEqual('/device:GPU:3', c.device)
+
+      cc = variables.Variable(0.02)
+      self.assertEqual('/device:GPU:3', cc.device)
+
+      ccc = variables.Variable(0.03)
+      self.assertEqual('/device:GPU:3', ccc.device)
+
+      c_op = array_ops.concat(c, axis=0)
+      self.assertEqual('/device:GPU:2', c_op.device)
+
+      cc_op = array_ops.concat(cc, axis=0)
+      self.assertEqual('/device:GPU:2', cc_op.device)
+
+
+class ComputeSumWithDevicePlacementTest(test_util.TensorFlowTestCase):
+
+  def test_example(self):
+    with self.test_session() as session:
+      total = replicate_model_fn._compute_sum_on_device(
+          [1.0, 2.0, 3.0, 4.0], device='/device:GPU:0', name='test_sum')
+
+      self.assertEqual('/device:GPU:0', total.device)
+      self.assertEqual('test_sum', total.op.name)
+      self.assertEqual(10.0, session.run(total))
+
+
+class ConcatTensorDictsTest(test_util.TensorFlowTestCase):
+
+  def test_example(self):
+    tensor_dicts = [
+        {
+            'a': np.array([1.0, 2.0]),
+            'b': np.array([11.0]),
+            'c': np.array([21.0]),
+        },
+        {
+            'a': np.array([3.0]),
+            'b': np.array([12.0, 13.0]),
+        },
+        {
+            'b': np.array([14.0]),
+        },
+    ]
+
+    with self.test_session() as session:
+      self.assertAllClose({
+          'a': np.array([1.0, 2.0, 3.0]),
+          'b': np.array([11.0, 12.0, 13.0, 14.0]),
+          'c': np.array([21.0]),
+      }, session.run(replicate_model_fn._concat_tensor_dicts(*tensor_dicts)))
+
+
+if __name__ == '__main__':
+  test.main()
diff --git a/tensorflow/contrib/framework/BUILD b/tensorflow/contrib/framework/BUILD
index 891425fd8cae6fbbf60d30cbd9137c049073456c..e8dad886a1409babdf4ea47b9cd05def1f1ce25e 100644
--- a/tensorflow/contrib/framework/BUILD
+++ b/tensorflow/contrib/framework/BUILD
@@ -24,6 +24,7 @@ tf_custom_op_py_library(
         "python/framework/__init__.py",
         "python/framework/checkpoint_utils.py",
         "python/framework/experimental.py",
+        "python/framework/graph_util.py",
         "python/framework/tensor_util.py",
         "python/ops/__init__.py",
         "python/ops/accumulate_n_v2.py",
@@ -32,6 +33,7 @@ tf_custom_op_py_library(
         "python/ops/checkpoint_ops.py",
         "python/ops/ops.py",
         "python/ops/prettyprint_ops.py",
+        "python/ops/sort_ops.py",
         "python/ops/variables.py",
     ],
     dso = [
@@ -231,6 +233,17 @@ py_test(
     ],
 )
 
+py_test(
+    name = "graph_util_test",
+    srcs = ["python/framework/graph_util_test.py"],
+    srcs_version = "PY2AND3",
+    deps = [
+        ":framework_py",
+        "//tensorflow/python:client_testlib",
+        "//tensorflow/python:platform",
+    ],
+)
+
 py_test(
     name = "tensor_util_test",
     srcs = ["python/framework/tensor_util_test.py"],
@@ -307,6 +320,20 @@ py_test(
     ],
 )
 
+py_test(
+    name = "sort_ops_test",
+    size = "medium",
+    srcs = ["python/ops/sort_ops_test.py"],
+    srcs_version = "PY2AND3",
+    deps = [
+        ":framework_py",
+        "//tensorflow/python:array_ops",
+        "//tensorflow/python:client_testlib",
+        "//tensorflow/python:random_ops",
+        "//third_party/py/numpy",
+    ],
+)
+
 filegroup(
     name = "all_files",
     srcs = glob(
diff --git a/tensorflow/contrib/framework/__init__.py b/tensorflow/contrib/framework/__init__.py
index 8421ba7c0423c6ed274f92ba74930822d0171e05..3f592611830e40a30392239c85486a2fad15a2a2 100644
--- a/tensorflow/contrib/framework/__init__.py
+++ b/tensorflow/contrib/framework/__init__.py
@@ -79,6 +79,8 @@ See the @{$python/contrib.framework} guide.
 @@load_embedding_initializer
 @@load_linear_multiclass_bias_initializer
 @@load_variable_slot_initializer
+
+@@sort
 """
 
 from __future__ import absolute_import
diff --git a/tensorflow/contrib/framework/python/framework/__init__.py b/tensorflow/contrib/framework/python/framework/__init__.py
index c8e6a4685498a4d89cef44f6a9a3acbe7557cb67..2d49771ab756359712a3ee0b23649c231678f952 100644
--- a/tensorflow/contrib/framework/python/framework/__init__.py
+++ b/tensorflow/contrib/framework/python/framework/__init__.py
@@ -21,6 +21,7 @@ from __future__ import print_function
 # pylint: disable=wildcard-import
 from tensorflow.contrib.framework.python.framework.checkpoint_utils import *
 from tensorflow.contrib.framework.python.framework.experimental import experimental
+from tensorflow.contrib.framework.python.framework.graph_util import *
 from tensorflow.contrib.framework.python.framework.tensor_util import *
 # pylint: enable=wildcard-import
 from tensorflow.python.util import decorator_utils
diff --git a/tensorflow/contrib/framework/python/framework/graph_util.py b/tensorflow/contrib/framework/python/framework/graph_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ab8711db4650921e0d366a91adfe2f68b5a42f9
--- /dev/null
+++ b/tensorflow/contrib/framework/python/framework/graph_util.py
@@ -0,0 +1,128 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Helpers to manipulate a tensor graph in python.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import copy
+import six
+
+# pylint: disable=unused-import
+from tensorflow.core.framework import graph_pb2
+from tensorflow.core.framework import node_def_pb2
+from tensorflow.python.framework.graph_util_impl import _assert_nodes_are_present
+from tensorflow.python.framework.graph_util_impl import _bfs_for_reachable_nodes
+from tensorflow.python.framework.graph_util_impl import _extract_graph_summary
+from tensorflow.python.framework.graph_util_impl import _node_name
+
+__all__ = ["fuse_op"]
+
+
+def fuse_op(graph_def, input_nodes, output_nodes, output_dtypes,
+            output_quantized, op_name, op_type):
+  """Fuse subgraph between input_nodes and output_nodes into a single custom op.
+
+  Args:
+    graph_def: A graph_pb2.GraphDef proto.
+    input_nodes: input nodes to the subgraph to be fused.
+    output_nodes: output nodes to the subgraph to be fused.
+    output_dtypes: A list of output datatypes for the custom op
+    output_quantized: A boolean flag that indicates if output is quantized
+    op_name: fused op name.
+    op_type: fused op type.
+  Returns:
+    The GraphDef of the new graph.
+
+  Raises:
+    TypeError: If 'graph_def' is not a graph_pb2.GraphDef proto.
+  """
+
+  if not isinstance(graph_def, graph_pb2.GraphDef):
+    raise TypeError("graph_def must be a graph_pb2.GraphDef proto.")
+
+  if isinstance(input_nodes, six.string_types):
+    raise TypeError("input_nodes must be a list.")
+
+  if isinstance(output_nodes, six.string_types):
+    raise TypeError("output_nodes must be a list.")
+
+  name_to_input_name, name_to_node, name_to_seq_num = _extract_graph_summary(
+      graph_def)
+  _assert_nodes_are_present(name_to_node, input_nodes + output_nodes)
+
+  # Nodes upto and including input_nodes
+  reachable_by_input = _bfs_for_reachable_nodes(input_nodes, name_to_input_name)
+  # Nodes upto and including output_nodes
+  reachable_by_output = _bfs_for_reachable_nodes(output_nodes,
+                                                 name_to_input_name)
+
+  # Set of nodes in the list input_nodes
+  input_nodes_set = set(input_nodes)
+
+  # Set of nodes in the list output_nodes
+  output_nodes_set = set(output_nodes)
+
+  nodes_post_output = []
+  for node in graph_def.node:
+    n = _node_name(node.name)
+    if n in reachable_by_output:
+      if n not in reachable_by_input and n not in output_nodes_set:
+        # n is between input and output, i.e., part of the fused op
+        next_to_visit = [n]
+        while next_to_visit:
+          cur_node = next_to_visit[0]
+          del next_to_visit[0]
+          if cur_node in reachable_by_input and cur_node not in input_nodes_set:
+            raise TypeError("Node %s uses input %s not in input_nodes." %
+                            (n, cur_node))
+          if cur_node not in input_nodes_set:
+            next_to_visit += name_to_input_name[cur_node]
+    else:
+      nodes_post_output.append(n)
+
+  # Add all nodes upto the input nodes
+  out = graph_pb2.GraphDef()
+  reachable_by_input_sorted = sorted(
+      list(reachable_by_input), key=lambda n: name_to_seq_num[n])
+  for node in reachable_by_input_sorted:
+    out.node.extend([copy.deepcopy(name_to_node[node])])
+
+  # Add the custom op
+  new_node = node_def_pb2.NodeDef()
+  for node in input_nodes:
+    new_node.input.append(node)
+  new_node.attr["_output_types"].list.type[:] = output_dtypes
+  new_node.attr["_output_quantized"].b = output_quantized
+  new_node.op = op_type
+  new_node.name = op_name
+  out.node.extend([new_node])
+
+  # Add the nodes in the output of the custom op
+  for index, n in enumerate(output_nodes):
+    assert len(name_to_node[n].input) == 1
+    new_node = copy.deepcopy(name_to_node[n])
+    del new_node.input[:]
+    new_node.input.append(op_name + (":" + str(index) if index != 0 else ""))
+    out.node.extend([new_node])
+
+  # Add the nodes post output_nodes
+  for n in nodes_post_output:
+    out.node.extend([copy.deepcopy(name_to_node[n])])
+
+  out.library.CopyFrom(graph_def.library)
+  out.versions.CopyFrom(graph_def.versions)
+  return out
diff --git a/tensorflow/contrib/framework/python/framework/graph_util_test.py b/tensorflow/contrib/framework/python/framework/graph_util_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..87b992e22e1ad3aa20389d0834eeb3a5972c676e
--- /dev/null
+++ b/tensorflow/contrib/framework/python/framework/graph_util_test.py
@@ -0,0 +1,61 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""@graph_util tests."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from tensorflow.contrib.framework.python.framework import graph_util
+from tensorflow.core.framework import graph_pb2
+from tensorflow.core.framework import node_def_pb2
+from tensorflow.core.framework import types_pb2
+from tensorflow.python.platform import test
+
+
+def GetNewNode(name, op, input_nodes):
+  new_node = node_def_pb2.NodeDef()
+  new_node.op = op
+  new_node.name = name
+  for node in input_nodes:
+    new_node.input.append(node)
+  return new_node
+
+
+class GraphUtilTest(test.TestCase):
+
+  def testGraphUtil(self):
+    graph_def = graph_pb2.GraphDef()
+    node_a = GetNewNode('A', 'Placeholder', [])
+    node_b = GetNewNode('B', 'Op1', ['A'])
+    node_c = GetNewNode('C', 'Op1', ['B'])
+    node_d = GetNewNode('D', 'Op1', ['C'])
+    node_e = GetNewNode('E', 'Op1', ['D'])
+    graph_def.node.extend([node_a, node_b, node_c, node_d, node_e])
+    fused_graph_def = graph_util.fuse_op(
+        graph_def, ['A'], ['D'], [types_pb2.DT_FLOAT], True, 'FusedOp', 'Op2')
+    self.assertEqual(len(fused_graph_def.node), 4)
+    self.assertEqual(fused_graph_def.node[0].name, 'A')
+    self.assertEqual(fused_graph_def.node[1].name, 'FusedOp')
+    self.assertEqual(fused_graph_def.node[1].input[0], 'A')
+    self.assertEqual(fused_graph_def.node[1].op, 'Op2')
+    self.assertEqual(fused_graph_def.node[1].attr['_output_quantized'].b, True)
+    self.assertEqual(fused_graph_def.node[1].attr['_output_types'].list.type,
+                     [types_pb2.DT_FLOAT])
+    self.assertEqual(fused_graph_def.node[2].name, 'D')
+    self.assertEqual(fused_graph_def.node[3].name, 'E')
+
+
+if __name__ == '__main__':
+  test.main()
diff --git a/tensorflow/contrib/framework/python/ops/__init__.py b/tensorflow/contrib/framework/python/ops/__init__.py
index edef37cf0c0719bf10a4c75c34adb30b9716cdcd..685bb94779762ce46ee342e7e0a182c54be64743 100644
--- a/tensorflow/contrib/framework/python/ops/__init__.py
+++ b/tensorflow/contrib/framework/python/ops/__init__.py
@@ -24,5 +24,6 @@ from tensorflow.contrib.framework.python.ops.arg_scope import *
 from tensorflow.contrib.framework.python.ops.checkpoint_ops import *
 from tensorflow.contrib.framework.python.ops.ops import *
 from tensorflow.contrib.framework.python.ops.prettyprint_ops import *
+from tensorflow.contrib.framework.python.ops.sort_ops import *
 from tensorflow.contrib.framework.python.ops.variables import *
 # pylint: enable=wildcard-import
diff --git a/tensorflow/contrib/framework/python/ops/sort_ops.py b/tensorflow/contrib/framework/python/ops/sort_ops.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f62f0ea7b9b561f235b9496ffda97a9f378d530
--- /dev/null
+++ b/tensorflow/contrib/framework/python/ops/sort_ops.py
@@ -0,0 +1,113 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Support for sorting tensors.
+
+@@sort
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from tensorflow.python.framework import ops as framework_ops
+from tensorflow.python.framework import tensor_util
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import math_ops
+from tensorflow.python.ops import nn_ops
+
+
+def sort(values, axis=-1, direction='ASCENDING', name=None):
+  """Sorts a tensor.
+
+  Args:
+    values: 1-D or higher numeric `Tensor`.
+    axis: The axis along which to sort. The default is -1, which sorts the last
+        axis.
+    direction: The direction in which to sort the values (`'ASCENDING'` or
+        `'DESCENDING'`).
+    name: Optional name for the operation.
+
+  Returns:
+    A `Tensor` with the same dtype and shape as `values`, with the elements
+        sorted along the given `axis`.
+
+  Raises:
+    ValueError: If axis is not a constant scalar, or the direction is invalid.
+  """
+  with framework_ops.name_scope(name, 'sort'):
+    if direction not in _SORT_IMPL:
+      raise ValueError('%s should be one of %s' %
+                       (direction, ', '.join(sorted(_SORT_IMPL.keys()))))
+    # Axis must be an integer, not a Tensor.
+    axis = framework_ops.convert_to_tensor(axis, name='axis')
+    axis_static = tensor_util.constant_value(axis)
+    if axis.shape.ndims != 0 or axis_static is None:
+      raise ValueError('axis must be a constant scalar')
+    axis_static = int(axis_static)  # Avoids NumPy casting error
+
+    values = framework_ops.convert_to_tensor(values, name='values')
+
+    return _SORT_IMPL[direction](values, axis_static)
+
+
+def _descending_sort(values, axis):
+  """Sorts values in reverse using `top_k`.
+
+  Args:
+    values: Tensor of numeric values.
+    axis: Index of the axis which values should be sorted along.
+
+  Returns:
+    The sorted values.
+  """
+  k = array_ops.shape(values)[axis]
+  rank = array_ops.rank(values)
+  # Fast path: sorting the last axis.
+  if axis == -1 or axis + 1 == values.get_shape().ndims:
+    return nn_ops.top_k(values, k)[0]
+
+  # Otherwise, transpose the array. Swap axes `axis` and `rank - 1`.
+  if axis < 0:
+    # Make axis a Tensor with the real axis index if needed.
+    axis += rank
+  transposition = array_ops.concat(
+      [
+          # Axes up to axis are unchanged.
+          math_ops.range(axis),
+          # Swap axis and rank - 1.
+          [rank - 1],
+          # Axes in [axis + 1, rank - 1) are unchanged.
+          math_ops.range(axis + 1, rank - 1),
+          # Swap axis and rank - 1.
+          [axis]
+      ],
+      axis=0)
+  top_k_input = array_ops.transpose(values, transposition)
+  values, unused_indices = nn_ops.top_k(top_k_input, k)
+  # transposition contains a single cycle of length 2 (swapping 2 elements),
+  # so it is an involution (it is its own inverse).
+  return array_ops.transpose(values, transposition)
+
+
+def _ascending_sort(values, axis):
+  # Negate the values to get the ascending order from descending sort.
+  values_or_indices = _descending_sort(-values, axis)
+  return -values_or_indices
+
+
+_SORT_IMPL = {
+    'ASCENDING': _ascending_sort,
+    'DESCENDING': _descending_sort,
+}
diff --git a/tensorflow/contrib/framework/python/ops/sort_ops_test.py b/tensorflow/contrib/framework/python/ops/sort_ops_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..d08ae502f10d98ee14d8bea2f76b18bedb935cea
--- /dev/null
+++ b/tensorflow/contrib/framework/python/ops/sort_ops_test.py
@@ -0,0 +1,95 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for the sort wrapper."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+
+from tensorflow.contrib.framework.python.ops import sort_ops
+from tensorflow.python.framework import constant_op
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import errors
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import random_ops
+from tensorflow.python.platform import test
+
+
+class SortTest(test.TestCase):
+
+  def testRandom_lowDimensionality(self):
+    self._testRandom_lowDimensionality(negative_axis=False)
+
+  def testRandom_lowDimensionality_negative(self):
+    self._testRandom_lowDimensionality(negative_axis=True)
+
+  def _testRandom_lowDimensionality(self, negative_axis):
+    np.random.seed(42)
+    for _ in range(20):
+      rank = np.random.randint(1, 3)
+      shape = [np.random.randint(0, 20) for _ in range(rank)]
+      arr = np.random.random(shape)
+      sort_axis = np.random.choice(rank)
+      if negative_axis:
+        sort_axis = -1 - sort_axis
+      with self.test_session():
+        self.assertAllEqual(
+            np.sort(arr, axis=sort_axis),
+            sort_ops.sort(constant_op.constant(arr), axis=sort_axis).eval())
+
+  def testRandom_highDimensionality(self):
+    np.random.seed(100)
+    for _ in range(20):
+      rank = np.random.randint(5, 15)
+      shape = [np.random.randint(1, 4) for _ in range(rank)]
+      arr = np.random.random(shape)
+      sort_axis = np.random.choice(rank)
+      with self.test_session():
+        self.assertAllEqual(
+            np.sort(arr, axis=sort_axis),
+            sort_ops.sort(constant_op.constant(arr), axis=sort_axis).eval())
+
+  def testScalar(self):
+    # Create an empty scalar where the static shape is unknown.
+    zeros_length_1 = array_ops.zeros(
+        random_ops.random_uniform([1], minval=0, maxval=1, dtype=dtypes.int32),
+        dtype=dtypes.int32)
+    scalar = array_ops.zeros(zeros_length_1)
+
+    sort = sort_ops.sort(scalar)
+    with self.test_session():
+      with self.assertRaises(errors.InvalidArgumentError):
+        sort.eval()
+
+  def testNegativeOutOfBounds_staticShape(self):
+    arr = constant_op.constant([3, 4, 5])
+    with self.assertRaises(ValueError):
+      sort_ops.sort(arr, axis=-4)
+
+  def testDescending(self):
+    arr = np.random.random((10, 5, 5))
+    with self.test_session():
+      self.assertAllEqual(
+          np.sort(arr, axis=0)[::-1],
+          sort_ops.sort(
+              constant_op.constant(arr),
+              axis=0,
+              direction='DESCENDING').eval())
+
+
+if __name__ == '__main__':
+  test.main()
diff --git a/tensorflow/contrib/learn/python/learn/learn_io/data_feeder.py b/tensorflow/contrib/learn/python/learn/learn_io/data_feeder.py
index 4c50d40aaa9b3c5d94d0a66d08e8ab6173db427a..db18ebf05d5fb98e28e767be7bcccdf992a56fd8 100644
--- a/tensorflow/contrib/learn/python/learn/learn_io/data_feeder.py
+++ b/tensorflow/contrib/learn/python/learn/learn_io/data_feeder.py
@@ -28,13 +28,14 @@ import six
 from six.moves import xrange  # pylint: disable=redefined-builtin
 
 from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor_util
 from tensorflow.python.ops import array_ops
 from tensorflow.python.platform import tf_logging as logging
 
 # pylint: disable=g-multiple-import,g-bad-import-order
 from .pandas_io import HAS_PANDAS, extract_pandas_data, extract_pandas_matrix, extract_pandas_labels
 from .dask_io import HAS_DASK, extract_dask_data, extract_dask_labels
-
 # pylint: enable=g-multiple-import,g-bad-import-order
 
 
@@ -365,8 +366,13 @@ class DataFeeder(object):
     self.random_state = np.random.RandomState(
         42) if random_state is None else random_state
 
-    num_samples = list(self._x.values())[0].shape[
-        0] if x_is_dict else self._x.shape[0]
+    if x_is_dict:
+      num_samples = list(self._x.values())[0].shape[0]
+    elif tensor_util.is_tensor(self._x):
+      num_samples = self._x.shape[0].value  # shape will be a Dimension, extract an int
+    else:
+      num_samples = self._x.shape[0]
+      
     if self._shuffle:
       self.indices = self.random_state.permutation(num_samples)
     else:
diff --git a/tensorflow/contrib/metrics/python/ops/metric_ops.py b/tensorflow/contrib/metrics/python/ops/metric_ops.py
index 33377a70c2506261b497c1b0fe8ab5ba0c680c7e..3dd1f1a627738a7e1f6eead8c8c0eaae237190a3 100644
--- a/tensorflow/contrib/metrics/python/ops/metric_ops.py
+++ b/tensorflow/contrib/metrics/python/ops/metric_ops.py
@@ -1982,7 +1982,7 @@ def streaming_sparse_precision_at_k(predictions,
       `predictions`, or if either `metrics_collections` or `updates_collections`
       are not a list or tuple.
   """
-  return metrics.sparse_precision_at_k(
+  return metrics.precision_at_k(
       k=k,
       class_id=class_id,
       predictions=predictions,
@@ -2323,7 +2323,7 @@ def streaming_sparse_average_precision_at_k(predictions,
     update: `Operation` that increments variables appropriately, and whose
       value matches `metric`.
   """
-  return metrics.sparse_average_precision_at_k(
+  return metrics.average_precision_at_k(
       k=k,
       predictions=predictions,
       labels=labels,
diff --git a/tensorflow/contrib/model_pruning/README.md b/tensorflow/contrib/model_pruning/README.md
index a8427e60144445c008d032ff2cbfd801d294974c..764e126e0d64d5e6c6caf0a9f0d43a87995447eb 100644
--- a/tensorflow/contrib/model_pruning/README.md
+++ b/tensorflow/contrib/model_pruning/README.md
@@ -20,7 +20,7 @@ conv = tf.nn.conv2d(images, pruning.apply_mask(weights), stride, padding)
 
 This creates a convolutional layer with additional variables mask and threshold
 as shown below: ![Convolutional layer with mask and
-threshold](./mask.png "Convolutional layer with mask and threshold")
+threshold](https://storage.googleapis.com/download.tensorflow.org/example_images/mask.png "Convolutional layer with mask and threshold")
 
 Alternatively, the API also provides variant of tensorflow layers with these
 auxiliary variables built-in (see
@@ -37,82 +37,20 @@ auxiliary variables built-in (see
 
 The pruning library allows for specification of the following hyper parameters:
 
-| Hyperparameter               | Type    | Default       | Description    |
-| ---------------------------- | ------- | ------------- | -------------- |
-| name                         | string  | model_pruning | Name of the    |
-:                              :         :               : pruning        :
-:                              :         :               : specification. :
-:                              :         :               : Used for       :
-:                              :         :               : adding         :
-:                              :         :               : summaries and  :
-:                              :         :               : ops under a    :
-:                              :         :               : common         :
-:                              :         :               : tensorflow     :
-:                              :         :               : name_scope     :
-| begin_pruning_step           | integer | 0             | The global     |
-:                              :         :               : step at which  :
-:                              :         :               : to begin       :
-:                              :         :               : pruning        :
-| end_pruning_step             | integer | -1            | The global     |
-:                              :         :               : step at which  :
-:                              :         :               : to terminate   :
-:                              :         :               : pruning.       :
-:                              :         :               : Defaults to -1 :
-:                              :         :               : implying that  :
-:                              :         :               : pruning        :
-:                              :         :               : continues till :
-:                              :         :               : the training   :
-:                              :         :               : stops          :
-| do_not_prune                 | list of | [""]          | list of layers |
-:                              : strings :               : that are not   :
-:                              :         :               : pruned         :
-| threshold_decay              | float   | 0.9           | The decay      |
-:                              :         :               : factor to use  :
-:                              :         :               : for            :
-:                              :         :               : exponential    :
-:                              :         :               : decay of the   :
-:                              :         :               : thresholds     :
-| pruning_frequency            | integer | 10            | How often      |
-:                              :         :               : should the     :
-:                              :         :               : masks be       :
-:                              :         :               : updated? (in # :
-:                              :         :               : of             :
-:                              :         :               : global_steps). :
-| nbins                        | integer | 255           | Number of bins |
-:                              :         :               : to use for     :
-:                              :         :               : histogram      :
-:                              :         :               : computation    :
-| initial_sparsity             | float   | 0.0           | Initial        |
-:                              :         :               : sparsity value :
-| target_sparsity              | float   | 0.5           | Target         |
-:                              :         :               : sparsity value :
-| sparsity_function_begin_step | integer | 0             | The global     |
-:                              :         :               : step at this   :
-:                              :         :               : which the      :
-:                              :         :               : gradual        :
-:                              :         :               : sparsity       :
-:                              :         :               : function       :
-:                              :         :               : begins to take :
-:                              :         :               : effect         :
-| sparsity_function_end_step   | integer | 100           | The global     |
-:                              :         :               : step used as   :
-:                              :         :               : the end point  :
-:                              :         :               : for the        :
-:                              :         :               : gradual        :
-:                              :         :               : sparsity       :
-:                              :         :               : function       :
-| sparsity_function_exponent   | float   | 3.0           | exponent = 1   |
-:                              :         :               : is linearly    :
-:                              :         :               : varying        :
-:                              :         :               : sparsity       :
-:                              :         :               : between        :
-:                              :         :               : initial and    :
-:                              :         :               : final.         :
-:                              :         :               : exponent > 1   :
-:                              :         :               : varies more    :
-:                              :         :               : slowly towards :
-:                              :         :               : the end than   :
-:                              :         :               : the beginning  :
+|Hyperparameter               | Type    | Default       | Description |
+|:----------------------------|:-------:|:-------------:|:--------------|
+| name | string | model_pruning | Name of the pruning specification. Used for adding summaries and ops under a common tensorflow name_scope |
+| begin_pruning_step | integer | 0 | The global step at which to begin pruning |
+| end_pruning_step   | integer | -1 | The global step at which to terminate pruning. Defaults to -1 implying that pruning continues till  the training stops |
+| do_not_prune | list of strings | [""] | list of layers strings that are not pruned |
+| threshold_decay | float | 0.9 | The decay factor to use for exponential decay of the thresholds |
+| pruning_frequency | integer | 10 | How often should the masks be updated? (in # of global_steps) |
+| nbins | integer | 255 | Number of bins to use for histogram computation |
+| initial_sparsity | float | 0.0 | Initial sparsity value |
+| target_sparsity | float | 0.5 | Target sparsity value |
+| sparsity_function_begin_step | integer | 0 | The global step at this which the gradual sparsity function begins to take effect |
+| sparsity_function_end_step | integer | 100 | The global step used as the end point for the gradual sparsity function |
+| sparsity_function_exponent | float | 3.0 | exponent = 1 is linearly varying sparsity between initial and final. exponent > 1 varies more slowly towards the end than the beginning |
 
 The sparsity $$s_t$$ at global step $$t$$ is given by:
 
@@ -190,6 +128,3 @@ Eval:
 ```shell
 $ bazel-bin/$examples_dir/cifar10/cifar10_eval --run_once
 ```
-
-TODO(suyoggupta): Add figures showing the sparsity function, sparsity for
-different layers etc.
diff --git a/tensorflow/contrib/rnn/python/ops/rnn_cell.py b/tensorflow/contrib/rnn/python/ops/rnn_cell.py
index 7e0e41477c9e70fcfcc0163a6348d3170fc43e73..5e85c125df8ca0d632fa9b0db86d942bb354631e 100644
--- a/tensorflow/contrib/rnn/python/ops/rnn_cell.py
+++ b/tensorflow/contrib/rnn/python/ops/rnn_cell.py
@@ -1362,24 +1362,25 @@ class LayerNormBasicLSTMCell(rnn_cell_impl.RNNCell):
   def output_size(self):
     return self._num_units
 
-  def _norm(self, inp, scope):
+  def _norm(self, inp, scope, dtype=dtypes.float32):
     shape = inp.get_shape()[-1:]
     gamma_init = init_ops.constant_initializer(self._norm_gain)
     beta_init = init_ops.constant_initializer(self._norm_shift)
     with vs.variable_scope(scope):
       # Initialize beta and gamma for use by layer_norm.
-      vs.get_variable("gamma", shape=shape, initializer=gamma_init)
-      vs.get_variable("beta", shape=shape, initializer=beta_init)
+      vs.get_variable("gamma", shape=shape, initializer=gamma_init, dtype=dtype)
+      vs.get_variable("beta", shape=shape, initializer=beta_init, dtype=dtype)
     normalized = layers.layer_norm(inp, reuse=True, scope=scope)
     return normalized
 
   def _linear(self, args):
     out_size = 4 * self._num_units
     proj_size = args.get_shape()[-1]
-    weights = vs.get_variable("kernel", [proj_size, out_size])
+    dtype = args.dtype
+    weights = vs.get_variable("kernel", [proj_size, out_size], dtype=dtype)
     out = math_ops.matmul(args, weights)
     if not self._layer_norm:
-      bias = vs.get_variable("bias", [out_size])
+      bias = vs.get_variable("bias", [out_size], dtype=dtype)
       out = nn_ops.bias_add(out, bias)
     return out
 
@@ -1388,13 +1389,14 @@ class LayerNormBasicLSTMCell(rnn_cell_impl.RNNCell):
     c, h = state
     args = array_ops.concat([inputs, h], 1)
     concat = self._linear(args)
+    dtype = args.dtype
 
     i, j, f, o = array_ops.split(value=concat, num_or_size_splits=4, axis=1)
     if self._layer_norm:
-      i = self._norm(i, "input")
-      j = self._norm(j, "transform")
-      f = self._norm(f, "forget")
-      o = self._norm(o, "output")
+      i = self._norm(i, "input", dtype=dtype)
+      j = self._norm(j, "transform", dtype=dtype)
+      f = self._norm(f, "forget", dtype=dtype)
+      o = self._norm(o, "output", dtype=dtype)
 
     g = self._activation(j)
     if (not isinstance(self._keep_prob, float)) or self._keep_prob < 1:
@@ -1403,7 +1405,7 @@ class LayerNormBasicLSTMCell(rnn_cell_impl.RNNCell):
     new_c = (c * math_ops.sigmoid(f + self._forget_bias)
              + math_ops.sigmoid(i) * g)
     if self._layer_norm:
-      new_c = self._norm(new_c, "state")
+      new_c = self._norm(new_c, "state", dtype=dtype)
     new_h = self._activation(new_c) * math_ops.sigmoid(o)
 
     new_state = rnn_cell_impl.LSTMStateTuple(new_c, new_h)
diff --git a/tensorflow/contrib/summary/summary_ops.py b/tensorflow/contrib/summary/summary_ops.py
index ecfa6baeff35ce6b25185a686d528ec73f17c1ee..56e31985936c22d9b5d6c85fff067118152e220d 100644
--- a/tensorflow/contrib/summary/summary_ops.py
+++ b/tensorflow/contrib/summary/summary_ops.py
@@ -246,8 +246,8 @@ def image(name, tensor, bad_color=None, max_images=3, family=None):
   """Writes an image summary if possible."""
 
   def function(tag, scope):
-    if bad_color is None:
-      bad_color_ = constant_op.constant([255, 0, 0, 255], dtype=dtypes.uint8)
+    bad_color_ = (constant_op.constant([255, 0, 0, 255], dtype=dtypes.uint8)
+                  if bad_color is None else bad_color)
     # Note the identity to move the tensor to the CPU.
     return gen_summary_ops.write_image_summary(
         context.context().summary_writer_resource,
diff --git a/tensorflow/contrib/tpu/profiler/BUILD b/tensorflow/contrib/tpu/profiler/BUILD
index f6309e2e72f75a4ba5b323b4d7348c49555d522e..0e1fca3d3c8b6f3a19b3e989dbee1863475796c5 100644
--- a/tensorflow/contrib/tpu/profiler/BUILD
+++ b/tensorflow/contrib/tpu/profiler/BUILD
@@ -95,3 +95,10 @@ tf_proto_library_cc(
     cc_api_version = 2,
     visibility = ["//visibility:public"],
 )
+
+tf_proto_library_cc(
+    name = "tf_op_stats_proto",
+    srcs = ["tf_op_stats.proto"],
+    cc_api_version = 2,
+    visibility = ["//visibility:public"],
+)
diff --git a/tensorflow/contrib/tpu/profiler/tf_op_stats.proto b/tensorflow/contrib/tpu/profiler/tf_op_stats.proto
new file mode 100644
index 0000000000000000000000000000000000000000..5b2dbb31243d401fbab31bab5bc86133896693fe
--- /dev/null
+++ b/tensorflow/contrib/tpu/profiler/tf_op_stats.proto
@@ -0,0 +1,127 @@
+// This proto describes the format of tensorflow operation level stats for
+// profiling (in tensorboard) purpose.
+
+syntax = "proto2";
+
+package tensorflow.tpu;
+
+// Result proto for OpMetrics.
+message OpMetricsResult {
+  // True if this OP is executed on the device; False if it is executed on the
+  // host.
+  optional bool on_device = 1;
+  reserved 2;  // was uint32 id.
+  // Name of this OP.
+  optional string name = 3;
+  // Rank of this OP.
+  optional uint64 rank = 4;
+  // The starting time in cycles of the last instance of this OP executed.
+  optional double last_starttime_in_cycles = 5;
+  // The ending time in cycles of the last instance of this OP executed.
+  optional double last_endtime_in_cycles = 6;
+  // If this OP (say A), is an immediate child of another OP (say B), this field
+  // stores the sum of duration in microseconds of A inside B. If A appears more
+  // than once in B, the duration of all A's appearances will be added together.
+  // This sum will be reset after the self-time of B is calculated so that it
+  // can be reused for a new parent OP.
+  optional double sum_of_duration_in_us_as_children = 7;
+  // Number of instances that this OP occurred.
+  optional uint64 occurrences = 8;
+  // Total time in microseconds spent in this OP (accumulated
+  // over all of its occurrences).
+  optional double total_time_in_us = 9;
+  // Total self time in microseconds spent in this OP
+  // (accumulated over all of its occurrences).
+  optional double total_self_time_in_us = 10;
+  // The total self time as a fraction of sum of all OP's
+  // total self time on the host.
+  optional double host_total_self_time_as_fraction_of_all_op_time = 11;
+  // Cumulative total self time in fraction on the host.
+  optional double host_cumulative_total_self_time_as_fraction_of_all_op_time =
+      12;
+  // The total self time as a fraction of sum of all OP's
+  // total self time on the device.
+  optional double device_total_self_time_as_fraction_of_all_op_time = 13;
+  // Cumulative total self time in fraction on the device.
+  optional double device_cumulative_total_self_time_as_fraction_of_all_op_time =
+      14;
+  // Total number of FLOPs incurred by this OP.
+  optional double total_flops = 15;
+  // Total time in microseconds that the MXU is occupied by this OP.
+  optional double total_bytes_accessed = 16;
+  // Total time in microseconds that the MXU is occupied by this OP.
+  optional double mxu_occupancy_in_us = 17;
+  // Total time in microseconds that the XU is occupied by this OP.
+  optional double xu_occupancy_in_us = 18;
+  // Total DMA access stall time in microseconds.
+  optional double total_dma_stall_in_us = 19;
+}
+
+// Result proto for OpMetricsDb.
+message OpMetricsDbResult {
+  // A bunch of OpMetricsResults.
+  repeated OpMetricsResult metrics_db = 1;
+}
+
+// Result proto for StepInfo.
+message StepInfoResult {
+  // The (micro) step number.
+  optional uint32 step_num = 1;
+  // The step duration in picoseconds.
+  optional uint64 duration_ps = 2;
+  // The infeed duration in picoseconds.
+  // Can turn into a map if we want a variable number of ops.
+  optional uint64 infeed_duration_ps = 3;
+}
+
+// Result proto for a sequence of steps.
+message StepSequenceResult {
+  // A sequence of StepInfoResults.
+  repeated StepInfoResult step_sequence = 1;
+}
+
+// Result proto for a StepDatabase.
+message StepDatabaseResult {
+  // A map from core_id to StepSequenceResult.
+  map<uint32, StepSequenceResult> step_sequence_per_core = 1;
+}
+
+// Result proto for Dashboard data.
+message DashboardResult {
+  // The total iteration time in nanoseconds.
+  optional double iteration_time_ns = 1;
+  // The total number of iterations.
+  optional int32 num_iterations = 2;
+  // The total computation time in nanoseconds.
+  optional double computation_time_ns = 3;
+  // The total number of computations.
+  optional int32 num_computations = 4;
+}
+
+// Result proto for HloExtraInfo.
+message HloExtraInfoResult {
+  // Category of the HLO op given by the compiler.
+  optional string category = 1;
+  // The long name of the HLO that includes the dimensions.
+  optional string long_name = 2;
+}
+
+// Result proto for HloExtraInfoMap.
+message HloExtraInfoMapResult {
+  // A map from HLO name to HloExtraInfo.
+  map<string, HloExtraInfoResult> hlo_extrainfo_map = 1;
+}
+
+// Result proto for TfStatsHelper.
+message TfOpStats {
+  // The result for the TF-metric database.
+  optional OpMetricsDbResult tf_metrics_db = 1;
+  // The result for the HLO-metric database.
+  optional OpMetricsDbResult hlo_metrics_db = 2;
+  // The result for the step database.
+  optional StepDatabaseResult step_db = 3;
+  // The result for the TPU dashboard.
+  optional DashboardResult dashboard = 4;
+  // The result for the HloExtraInfoMap.
+  optional HloExtraInfoMapResult hlo_extrainfo_map = 5;
+}
diff --git a/tensorflow/contrib/tpu/python/tpu/tpu_estimator.py b/tensorflow/contrib/tpu/python/tpu/tpu_estimator.py
index 5a3b8314291951b5dfce091dccb0dc9e5f7af3b5..060b3f912926fbaa56bc1150e50434a7ad22c847 100644
--- a/tensorflow/contrib/tpu/python/tpu/tpu_estimator.py
+++ b/tensorflow/contrib/tpu/python/tpu/tpu_estimator.py
@@ -66,7 +66,7 @@ _CROSS_REPLICA_SUM_OP = 'CrossReplicaSum'
 _RESERVED_PARAMS_KEYS = [_BATCH_SIZE_KEY]
 
 # TODO(b/65703635): Flip the value and remove all dead code.
-_WRAP_INPUT_FN_INTO_WHILE_LOOP = False
+_WRAP_INPUT_FN_INTO_WHILE_LOOP = True
 
 
 def _create_global_step(graph):
diff --git a/tensorflow/core/BUILD b/tensorflow/core/BUILD
index 7b535da0b2f751ef258580b678bec5022d671b82..9530af637ef953c293472d926281de77cf626752 100644
--- a/tensorflow/core/BUILD
+++ b/tensorflow/core/BUILD
@@ -1414,16 +1414,19 @@ LIB_INTERNAL_PUBLIC_HEADERS = tf_additional_lib_hdrs() + [
     "platform/tracing.h",
 ]
 
+# Replicated for lib_internal and lib_internal_impl.
+LIB_INTERNAL_DEFINES = (tf_additional_lib_defines() + [
+                            "TF_USE_SNAPPY",
+                        ] + tf_additional_verbs_lib_defines() +
+                        tf_additional_mpi_lib_defines() +
+                        tf_additional_gdr_lib_defines())
+
 cc_library(
     name = "lib_internal",
     srcs = LIB_INTERNAL_PRIVATE_HEADERS,
     hdrs = LIB_INTERNAL_PUBLIC_HEADERS,
     copts = tf_copts(),
-    defines = tf_additional_lib_defines() + [
-                  "TF_USE_SNAPPY",
-              ] + tf_additional_verbs_lib_defines() +
-              tf_additional_mpi_lib_defines() +
-              tf_additional_gdr_lib_defines(),
+    defines = LIB_INTERNAL_DEFINES,
     linkopts = select({
         "//tensorflow:freebsd": [],
         "//tensorflow:windows": [],
@@ -1477,6 +1480,7 @@ cc_library(
     ),
     hdrs = LIB_INTERNAL_PUBLIC_HEADERS,
     copts = tf_copts(),
+    defines = LIB_INTERNAL_DEFINES,
     deps = tf_additional_lib_deps() + [
         ":lib_hash_crc32c_accelerate_internal",
         ":lib_proto_parsing",
diff --git a/tensorflow/core/api_def/api_test.cc b/tensorflow/core/api_def/api_test.cc
index ceeb172fa0a9abf2ab7adcfc801b4bcb5fa04381..d95d958d5afaad58bdec82183be3d3a09cf4605d 100644
--- a/tensorflow/core/api_def/api_test.cc
+++ b/tensorflow/core/api_def/api_test.cc
@@ -46,92 +46,218 @@ constexpr char kDefaultApiDefDir[] =
     "tensorflow/core/api_def/base_api";
 constexpr char kOverridesFilePath[] =
     "tensorflow/cc/ops/op_gen_overrides.pbtxt";
-constexpr char kApiDefFileFormat[] = "api_def_%c.pbtxt";
-constexpr char kAlphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+constexpr char kApiDefFileFormat[] = "api_def_%s.pbtxt";
+constexpr char kApiDefFilePattern[] = "api_def_*.pbtxt";
 
-// Get map from first character to ApiDefs for ops
-// that start with that character.
-std::unordered_map<char, ApiDefs> GenerateApiDef(
-    const OpList& ops, const OpGenOverrides& overrides) {
+void FillBaseApiDef(ApiDef* api_def, const OpDef& op) {
+  api_def->set_graph_op_name(op.name());
+  // Add arg docs
+  for (auto& input_arg : op.input_arg()) {
+    if (!input_arg.description().empty()) {
+      auto* api_def_in_arg = api_def->add_in_arg();
+      api_def_in_arg->set_name(input_arg.name());
+      api_def_in_arg->set_description(input_arg.description());
+    }
+  }
+  for (auto& output_arg : op.output_arg()) {
+    if (!output_arg.description().empty()) {
+      auto* api_def_out_arg = api_def->add_out_arg();
+      api_def_out_arg->set_name(output_arg.name());
+      api_def_out_arg->set_description(output_arg.description());
+    }
+  }
+  // Add attr docs
+  for (auto& attr : op.attr()) {
+    if (!attr.description().empty()) {
+      auto* api_def_attr = api_def->add_attr();
+      api_def_attr->set_name(attr.name());
+      api_def_attr->set_description(attr.description());
+    }
+  }
+  // Add docs
+  api_def->set_summary(op.summary());
+  api_def->set_description(op.description());
+}
+
+// Checks if arg1 should be before arg2 according to ordering in args.
+bool CheckArgBefore(const ApiDef::Arg* arg1, const ApiDef::Arg* arg2,
+                    const protobuf::RepeatedPtrField<OpDef::ArgDef>& args) {
+  for (auto& arg : args) {
+    if (arg.name() == arg2->name()) {
+      return false;
+    } else if (arg.name() == arg1->name()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Checks if attr1 should be before attr2 according to ordering in op_def.
+bool CheckAttrBefore(const ApiDef::Attr* attr1, const ApiDef::Attr* attr2,
+                     const OpDef& op_def) {
+  for (auto& attr : op_def.attr()) {
+    if (attr.name() == attr2->name()) {
+      return false;
+    } else if (attr.name() == attr1->name()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Applies renames to args.
+void ApplyArgOverrides(
+    protobuf::RepeatedPtrField<ApiDef::Arg>* args,
+    const protobuf::RepeatedPtrField<OpGenOverride::Rename>& renames,
+    const protobuf::RepeatedPtrField<OpDef::ArgDef>& op_args,
+    const string& op_name) {
+  for (auto& rename : renames) {
+    // First check if rename is valid.
+    bool valid = false;
+    for (const auto& op_arg : op_args) {
+      if (op_arg.name() == rename.from()) {
+        valid = true;
+      }
+    }
+    QCHECK(valid) << rename.from() << " is not a valid argument for "
+                  << op_name;
+    bool found_arg = false;
+    // If Arg is already in ApiDef, just update it.
+    for (int i = 0; i < args->size(); ++i) {
+      auto* arg = args->Mutable(i);
+      if (arg->name() == rename.from()) {
+        arg->set_rename_to(rename.to());
+        found_arg = true;
+        break;
+      }
+    }
+    if (!found_arg) {  // not in ApiDef, add a new arg.
+      auto* new_arg = args->Add();
+      new_arg->set_name(rename.from());
+      new_arg->set_rename_to(rename.to());
+    }
+  }
+  // We don't really need a specific order here right now.
+  // However, it is clearer if order follows OpDef.
+  std::sort(args->pointer_begin(), args->pointer_end(),
+            [&](ApiDef::Arg* arg1, ApiDef::Arg* arg2) {
+              return CheckArgBefore(arg1, arg2, op_args);
+            });
+}
+
+// Returns existing attribute with the given name if such
+// attribute exists. Otherwise, adds a new attribute and returns it.
+ApiDef::Attr* FindOrAddAttr(ApiDef* api_def, const string attr_name) {
+  // If Attr is already in ApiDef, just update it.
+  for (int i = 0; i < api_def->attr_size(); ++i) {
+    auto* attr = api_def->mutable_attr(i);
+    if (attr->name() == attr_name) {
+      return attr;
+    }
+  }
+  // Add a new Attr.
+  auto* new_attr = api_def->add_attr();
+  new_attr->set_name(attr_name);
+  return new_attr;
+}
+
+// Applies renames and default values to attributes.
+void ApplyAttrOverrides(ApiDef* api_def, const OpGenOverride& op_override,
+                        const OpDef& op_def) {
+  for (auto& attr_rename : op_override.attr_rename()) {
+    auto* attr = FindOrAddAttr(api_def, attr_rename.from());
+    attr->set_rename_to(attr_rename.to());
+  }
+
+  for (auto& attr_default : op_override.attr_default()) {
+    auto* attr = FindOrAddAttr(api_def, attr_default.name());
+    *(attr->mutable_default_value()) = attr_default.value();
+  }
+  // We don't really need a specific order here right now.
+  // However, it is clearer if order follows OpDef.
+  std::sort(api_def->mutable_attr()->pointer_begin(),
+            api_def->mutable_attr()->pointer_end(),
+            [&](ApiDef::Attr* attr1, ApiDef::Attr* attr2) {
+              return CheckAttrBefore(attr1, attr2, op_def);
+            });
+}
+
+void ApplyOverridesToApiDef(ApiDef* api_def, const OpDef& op,
+                            const OpGenOverride& op_override) {
+  // Fill ApiDef with data based on op and op_override.
+  // Set visibility
+  if (op_override.skip()) {
+    api_def->set_visibility(ApiDef_Visibility_SKIP);
+  } else if (op_override.hide()) {
+    api_def->set_visibility(ApiDef_Visibility_HIDDEN);
+  }
+  // Add endpoints
+  if (!op_override.rename_to().empty()) {
+    api_def->add_endpoint()->set_name(op_override.rename_to());
+  } else if (!op_override.alias().empty()) {
+    api_def->add_endpoint()->set_name(op.name());
+  }
+
+  for (auto& alias : op_override.alias()) {
+    auto* endpoint = api_def->add_endpoint();
+    endpoint->set_name(alias);
+  }
+
+  ApplyArgOverrides(api_def->mutable_in_arg(), op_override.input_rename(),
+                    op.input_arg(), api_def->graph_op_name());
+  ApplyArgOverrides(api_def->mutable_out_arg(), op_override.output_rename(),
+                    op.output_arg(), api_def->graph_op_name());
+  ApplyAttrOverrides(api_def, op_override, op);
+}
+
+// Get map from ApiDef file path to corresponding ApiDefs proto.
+std::unordered_map<string, ApiDefs> GenerateApiDef(
+    const string& api_def_dir, const OpList& ops,
+    const OpGenOverrides& overrides) {
   std::unordered_map<string, OpGenOverride> name_to_override;
   for (const auto& op_override : overrides.op()) {
     name_to_override[op_override.name()] = op_override;
   }
 
-  std::unordered_map<char, ApiDefs> api_defs_map;
+  std::unordered_map<string, ApiDefs> api_defs_map;
 
   for (const auto& op : ops.op()) {
     CHECK(!op.name().empty())
         << "Encountered empty op name: %s" << op.DebugString();
-    const char file_id = toupper(op.name()[0]);
-    CHECK(isalpha(file_id)) << "Unexpected op name: " << op.name();
-    ApiDef* api_def = api_defs_map[file_id].add_op();
-    api_def->set_graph_op_name(op.name());
+    string file_path = io::JoinPath(api_def_dir, kApiDefFileFormat);
+    file_path = strings::Printf(file_path.c_str(), op.name().c_str());
+    ApiDef* api_def = api_defs_map[file_path].add_op();
+    FillBaseApiDef(api_def, op);
 
     if (name_to_override.find(op.name()) != name_to_override.end()) {
-      const auto& op_override = name_to_override[op.name()];
-      // Set visibility
-      if (op_override.skip()) {
-        api_def->set_visibility(ApiDef_Visibility_SKIP);
-      } else if (op_override.hide()) {
-        api_def->set_visibility(ApiDef_Visibility_HIDDEN);
-      }
-      // Add endpoints
-      if (!op_override.rename_to().empty()) {
-        auto* endpoint = api_def->add_endpoint();
-        endpoint->set_name(op_override.rename_to());
-      } else {
-        auto* endpoint = api_def->add_endpoint();
-        endpoint->set_name(op.name());
-      }
-      for (auto& alias : op_override.alias()) {
-        auto* endpoint = api_def->add_endpoint();
-        endpoint->set_name(alias);
-      }
-      // Add attributes
-      for (auto& attr : op.attr()) {
-        auto* api_def_attr = api_def->add_attr();
-        api_def_attr->set_name(attr.name());
-        for (auto& attr_override : op_override.attr_default()) {
-          if (attr.name() == attr_override.name()) {
-            *(api_def_attr->mutable_default_value()) = attr_override.value();
-          }
-        }
-        for (auto& attr_rename : op_override.attr_rename()) {
-          if (attr.name() == attr_rename.from()) {
-            api_def_attr->set_rename_to(attr_rename.to());
-          }
-        }
-      }
-    } else {
-      auto* endpoint = api_def->add_endpoint();
-      endpoint->set_name(op.name());
+      ApplyOverridesToApiDef(api_def, op, name_to_override[op.name()]);
     }
-    // Add docs
-    api_def->set_summary(op.summary());
-    api_def->set_description(op.description());
   }
   return api_defs_map;
 }
 
-// Reads golden api defs file with the given suffix.
-string GetGoldenApiDefsStr(Env* env, const string& api_files_dir, char suffix) {
-  string file_path = strings::Printf(
-      io::JoinPath(api_files_dir, kApiDefFileFormat).c_str(), suffix);
-  if (env->FileExists(file_path).ok()) {
+// Reads golden ApiDef files and returns a map from file name to ApiDef file
+// contents.
+std::unordered_map<string, string> GetGoldenApiDefs(
+    Env* env, const string& api_files_dir) {
+  std::vector<string> matching_paths;
+  TF_CHECK_OK(env->GetMatchingPaths(
+      io::JoinPath(api_files_dir, kApiDefFilePattern), &matching_paths));
+
+  std::unordered_map<string, string> file_path_to_api_def;
+  for (auto& file_path : matching_paths) {
     string file_contents;
-    TF_EXPECT_OK(ReadFileToString(env, file_path, &file_contents));
-    return file_contents;
+    TF_CHECK_OK(ReadFileToString(env, file_path, &file_contents));
+    file_path_to_api_def[file_path] = file_contents;
   }
-  return "";
+  return file_path_to_api_def;
 }
 
 void RunApiTest(bool update_api_def, const string& api_files_dir) {
   // Read C++ overrides file
-  string overrides_file_contents;
+  OpGenOverrides overrides;
   Env* env = Env::Default();
-  TF_EXPECT_OK(
-      ReadFileToString(env, kOverridesFilePath, &overrides_file_contents));
+  TF_EXPECT_OK(ReadTextProto(env, kOverridesFilePath, &overrides));
 
   // Read all ops
   OpList ops;
@@ -139,29 +265,22 @@ void RunApiTest(bool update_api_def, const string& api_files_dir) {
   const std::vector<string> multi_line_fields = {"description"};
 
   // Get expected ApiDefs
-  OpGenOverrides overrides;
-  auto new_api_defs_map = GenerateApiDef(ops, overrides);
+  const auto new_api_defs_map = GenerateApiDef(api_files_dir, ops, overrides);
 
   bool updated_at_least_one_file = false;
+  const auto golden_api_defs_map = GetGoldenApiDefs(env, api_files_dir);
 
-  for (char c : kAlphabet) {
-    string golden_api_defs_str = GetGoldenApiDefsStr(env, api_files_dir, c);
-    string new_api_defs_str = new_api_defs_map[c].DebugString();
+  for (auto new_api_entry : new_api_defs_map) {
+    const auto& file_path = new_api_entry.first;
+    const auto& golden_api_defs_str = golden_api_defs_map.at(file_path);
+    string new_api_defs_str = new_api_entry.second.DebugString();
     new_api_defs_str = PBTxtToMultiline(new_api_defs_str, multi_line_fields);
     if (golden_api_defs_str == new_api_defs_str) {
       continue;
     }
     if (update_api_def) {
-      string output_file_path =
-          io::JoinPath(api_files_dir, strings::Printf(kApiDefFileFormat, c));
-      if (new_api_defs_str.empty()) {
-        std::cout << "Deleting " << output_file_path << "..." << std::endl;
-        TF_EXPECT_OK(env->DeleteFile(output_file_path));
-      } else {
-        std::cout << "Updating " << output_file_path << "..." << std::endl;
-        TF_EXPECT_OK(
-            WriteStringToFile(env, output_file_path, new_api_defs_str));
-      }
+      std::cout << "Updating " << file_path << "..." << std::endl;
+      TF_EXPECT_OK(WriteStringToFile(env, file_path, new_api_defs_str));
       updated_at_least_one_file = true;
     } else {
       EXPECT_EQ(golden_api_defs_str, new_api_defs_str)
@@ -170,6 +289,21 @@ void RunApiTest(bool update_api_def, const string& api_files_dir) {
     }
   }
 
+  for (const auto& golden_api_entry : golden_api_defs_map) {
+    const auto& file_path = golden_api_entry.first;
+    if (new_api_defs_map.find(file_path) == new_api_defs_map.end()) {
+      if (update_api_def) {
+        std::cout << "Deleting " << file_path << "..." << std::endl;
+        TF_EXPECT_OK(env->DeleteFile(file_path));
+        updated_at_least_one_file = true;
+      } else {
+        EXPECT_EQ("", golden_api_entry.second)
+            << "To update golden API files, run "
+            << "tensorflow/core/api_def/update_api_def.sh.";
+      }
+    }
+  }
+
   if (update_api_def && !updated_at_least_one_file) {
     std::cout << "Api def files are already up to date." << std::endl;
   }
diff --git a/tensorflow/core/api_def/base_api/api_def_A.pbtxt b/tensorflow/core/api_def/base_api/api_def_A.pbtxt
deleted file mode 100644
index 8193d1bc624535c7894430284686e8664fb71a2d..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_A.pbtxt
+++ /dev/null
@@ -1,670 +0,0 @@
-op {
-  graph_op_name: "Abort"
-  endpoint {
-    name: "Abort"
-  }
-  summary: "Raise a exception to abort the process when called."
-  description: <<END
-If exit_without_error is true, the process will exit normally,
-otherwise it will exit with a SIGABORT signal.
-
-Returns nothing but an exception.
-END
-}
-op {
-  graph_op_name: "Abs"
-  endpoint {
-    name: "Abs"
-  }
-  summary: "Computes the absolute value of a tensor."
-  description: <<END
-Given a tensor `x`, this operation returns a tensor containing the absolute
-value of each element in `x`. For example, if x is an input element and y is
-an output element, this operation computes \\(y = |x|\\).
-END
-}
-op {
-  graph_op_name: "AccumulatorApplyGradient"
-  endpoint {
-    name: "AccumulatorApplyGradient"
-  }
-  summary: "Applies a gradient to a given accumulator."
-  description: <<END
-Does not add if local_step is lesser than the accumulator's global_step.
-END
-}
-op {
-  graph_op_name: "AccumulatorNumAccumulated"
-  endpoint {
-    name: "AccumulatorNumAccumulated"
-  }
-  summary: "Returns the number of gradients aggregated in the given accumulators."
-}
-op {
-  graph_op_name: "AccumulatorSetGlobalStep"
-  endpoint {
-    name: "AccumulatorSetGlobalStep"
-  }
-  summary: "Updates the accumulator with a new value for global_step."
-  description: <<END
-Logs warning if the accumulator's value is already higher than
-new_global_step.
-END
-}
-op {
-  graph_op_name: "AccumulatorTakeGradient"
-  endpoint {
-    name: "AccumulatorTakeGradient"
-  }
-  summary: "Extracts the average gradient in the given ConditionalAccumulator."
-  description: <<END
-The op blocks until sufficient (i.e., more than num_required)
-gradients have been accumulated.  If the accumulator has already
-aggregated more than num_required gradients, it returns the average of
-the accumulated gradients.  Also automatically increments the recorded
-global_step in the accumulator by 1, and resets the aggregate to 0.
-END
-}
-op {
-  graph_op_name: "Acos"
-  endpoint {
-    name: "Acos"
-  }
-  summary: "Computes acos of x element-wise."
-}
-op {
-  graph_op_name: "Acosh"
-  endpoint {
-    name: "Acosh"
-  }
-  summary: "Computes inverse hyperbolic cosine of x element-wise."
-}
-op {
-  graph_op_name: "Add"
-  endpoint {
-    name: "Add"
-  }
-  summary: "Returns x + y element-wise."
-  description: <<END
-*NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "AddManySparseToTensorsMap"
-  endpoint {
-    name: "AddManySparseToTensorsMap"
-  }
-  summary: "Add an `N`-minibatch `SparseTensor` to a `SparseTensorsMap`, return `N` handles."
-  description: <<END
-A `SparseTensor` of rank `R` is represented by three tensors: `sparse_indices`,
-`sparse_values`, and `sparse_shape`, where
-
-```sparse_indices.shape[1] == sparse_shape.shape[0] == R```
-
-An `N`-minibatch of `SparseTensor` objects is represented as a `SparseTensor`
-having a first `sparse_indices` column taking values between `[0, N)`, where
-the minibatch size `N == sparse_shape[0]`.
-
-The input `SparseTensor` must have rank `R` greater than 1, and the first
-dimension is treated as the minibatch dimension.  Elements of the `SparseTensor`
-must be sorted in increasing order of this first dimension.  The stored
-`SparseTensor` objects pointed to by each row of the output `sparse_handles`
-will have rank `R-1`.
-
-The `SparseTensor` values can then be read out as part of a minibatch by passing
-the given keys as vector elements to `TakeManySparseFromTensorsMap`.  To ensure
-the correct `SparseTensorsMap` is accessed, ensure that the same
-`container` and `shared_name` are passed to that Op.  If no `shared_name`
-is provided here, instead use the *name* of the Operation created by calling
-`AddManySparseToTensorsMap` as the `shared_name` passed to
-`TakeManySparseFromTensorsMap`.  Ensure the Operations are colocated.
-END
-}
-op {
-  graph_op_name: "AddN"
-  endpoint {
-    name: "AddN"
-  }
-  summary: "Add all input tensors element wise."
-}
-op {
-  graph_op_name: "AddSparseToTensorsMap"
-  endpoint {
-    name: "AddSparseToTensorsMap"
-  }
-  summary: "Add a `SparseTensor` to a `SparseTensorsMap` return its handle."
-  description: <<END
-A `SparseTensor` is represented by three tensors: `sparse_indices`,
-`sparse_values`, and `sparse_shape`.
-
-This operator takes the given `SparseTensor` and adds it to a container
-object (a `SparseTensorsMap`).  A unique key within this container is generated
-in the form of an `int64`, and this is the value that is returned.
-
-The `SparseTensor` can then be read out as part of a minibatch by passing
-the key as a vector element to `TakeManySparseFromTensorsMap`.  To ensure
-the correct `SparseTensorsMap` is accessed, ensure that the same
-`container` and `shared_name` are passed to that Op.  If no `shared_name`
-is provided here, instead use the *name* of the Operation created by calling
-`AddSparseToTensorsMap` as the `shared_name` passed to
-`TakeManySparseFromTensorsMap`.  Ensure the Operations are colocated.
-END
-}
-op {
-  graph_op_name: "AdjustContrast"
-  endpoint {
-    name: "AdjustContrast"
-  }
-  summary: "Deprecated. Disallowed in GraphDef version >= 2."
-}
-op {
-  graph_op_name: "AdjustContrastv2"
-  endpoint {
-    name: "AdjustContrastv2"
-  }
-  summary: "Adjust the contrast of one or more images."
-  description: <<END
-`images` is a tensor of at least 3 dimensions.  The last 3 dimensions are
-interpreted as `[height, width, channels]`.  The other dimensions only
-represent a collection of images, such as `[batch, height, width, channels].`
-
-Contrast is adjusted independently for each channel of each image.
-
-For each channel, the Op first computes the mean of the image pixels in the
-channel and then adjusts each component of each pixel to
-`(x - mean) * contrast_factor + mean`.
-END
-}
-op {
-  graph_op_name: "AdjustHue"
-  endpoint {
-    name: "AdjustHue"
-  }
-  summary: "Adjust the hue of one or more images."
-  description: <<END
-`images` is a tensor of at least 3 dimensions.  The last dimension is
-interpretted as channels, and must be three.
-
-The input image is considered in the RGB colorspace. Conceptually, the RGB
-colors are first mapped into HSV. A delta is then applied all the hue values,
-and then remapped back to RGB colorspace.
-END
-}
-op {
-  graph_op_name: "AdjustSaturation"
-  endpoint {
-    name: "AdjustSaturation"
-  }
-  summary: "Adjust the saturation of one or more images."
-  description: <<END
-`images` is a tensor of at least 3 dimensions.  The last dimension is
-interpretted as channels, and must be three.
-
-The input image is considered in the RGB colorspace. Conceptually, the RGB
-colors are first mapped into HSV. A scale is then applied all the saturation
-values, and then remapped back to RGB colorspace.
-END
-}
-op {
-  graph_op_name: "All"
-  endpoint {
-    name: "All"
-  }
-  summary: "Computes the \"logical and\" of elements across dimensions of a tensor."
-  description: <<END
-Reduces `input` along the dimensions given in `reduction_indices`. Unless
-`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-`reduction_indices`. If `keep_dims` is true, the reduced dimensions are
-retained with length 1.
-END
-}
-op {
-  graph_op_name: "AllCandidateSampler"
-  endpoint {
-    name: "AllCandidateSampler"
-  }
-  summary: "Generates labels for candidate sampling with a learned unigram distribution."
-  description: <<END
-See explanations of candidate sampling and the data formats at
-go/candidate-sampling.
-
-For each batch, this op picks a single set of sampled candidate labels.
-
-The advantages of sampling candidates per-batch are simplicity and the
-possibility of efficient dense matrix multiplication. The disadvantage is that
-the sampled candidates must be chosen independently of the context and of the
-true labels.
-END
-}
-op {
-  graph_op_name: "Angle"
-  endpoint {
-    name: "Angle"
-  }
-  summary: "Returns the argument of a complex number."
-  description: <<END
-Given a tensor `input` of complex numbers, this operation returns a tensor of
-type `float` that is the argument of each element in `input`. All elements in
-`input` must be complex numbers of the form \\(a + bj\\), where *a*
-is the real part and *b* is the imaginary part.
-
-The argument returned by this operation is of the form \\(atan2(b, a)\\).
-
-For example:
-
-```
-# tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
-tf.angle(input) ==> [2.0132, 1.056]
-```
-
-@compatibility(numpy)
-Equivalent to np.angle.
-@end_compatibility
-END
-}
-op {
-  graph_op_name: "Any"
-  endpoint {
-    name: "Any"
-  }
-  summary: "Computes the \"logical or\" of elements across dimensions of a tensor."
-  description: <<END
-Reduces `input` along the dimensions given in `reduction_indices`. Unless
-`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-`reduction_indices`. If `keep_dims` is true, the reduced dimensions are
-retained with length 1.
-END
-}
-op {
-  graph_op_name: "ApplyAdadelta"
-  endpoint {
-    name: "ApplyAdadelta"
-  }
-  summary: "Update \'*var\' according to the adadelta scheme."
-  description: <<END
-accum = rho() * accum + (1 - rho()) * grad.square();
-update = (update_accum + epsilon).sqrt() * (accum + epsilon()).rsqrt() * grad;
-update_accum = rho() * update_accum + (1 - rho()) * update.square();
-var -= update;
-END
-}
-op {
-  graph_op_name: "ApplyAdagrad"
-  endpoint {
-    name: "ApplyAdagrad"
-  }
-  summary: "Update \'*var\' according to the adagrad scheme."
-  description: <<END
-accum += grad * grad
-var -= lr * grad * (1 / sqrt(accum))
-END
-}
-op {
-  graph_op_name: "ApplyAdagradDA"
-  endpoint {
-    name: "ApplyAdagradDA"
-  }
-  summary: "Update \'*var\' according to the proximal adagrad scheme."
-}
-op {
-  graph_op_name: "ApplyAdam"
-  endpoint {
-    name: "ApplyAdam"
-  }
-  summary: "Update \'*var\' according to the Adam algorithm."
-  description: <<END
-lr_t <- learning_rate * sqrt(1 - beta2^t) / (1 - beta1^t)
-m_t <- beta1 * m_{t-1} + (1 - beta1) * g_t
-v_t <- beta2 * v_{t-1} + (1 - beta2) * g_t * g_t
-variable <- variable - lr_t * m_t / (sqrt(v_t) + epsilon)
-END
-}
-op {
-  graph_op_name: "ApplyCenteredRMSProp"
-  endpoint {
-    name: "ApplyCenteredRMSProp"
-  }
-  summary: "Update \'*var\' according to the centered RMSProp algorithm."
-  description: <<END
-The centered RMSProp algorithm uses an estimate of the centered second moment
-(i.e., the variance) for normalization, as opposed to regular RMSProp, which
-uses the (uncentered) second moment. This often helps with training, but is
-slightly more expensive in terms of computation and memory.
-
-Note that in dense implementation of this algorithm, mg, ms, and mom will
-update even if the grad is zero, but in this sparse implementation, mg, ms,
-and mom will not update in iterations during which the grad is zero.
-
-mean_square = decay * mean_square + (1-decay) * gradient ** 2
-mean_grad = decay * mean_grad + (1-decay) * gradient
-
-Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2)
-
-mg <- rho * mg_{t-1} + (1-rho) * grad
-ms <- rho * ms_{t-1} + (1-rho) * grad * grad
-mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms - mg * mg + epsilon)
-var <- var - mom
-END
-}
-op {
-  graph_op_name: "ApplyFtrl"
-  endpoint {
-    name: "ApplyFtrl"
-  }
-  summary: "Update \'*var\' according to the Ftrl-proximal scheme."
-  description: <<END
-accum_new = accum + grad * grad
-linear += grad + (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
-quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
-var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
-accum = accum_new
-END
-}
-op {
-  graph_op_name: "ApplyFtrlV2"
-  endpoint {
-    name: "ApplyFtrlV2"
-  }
-  summary: "Update \'*var\' according to the Ftrl-proximal scheme."
-  description: <<END
-grad_with_shrinkage = grad + 2 * l2_shrinkage * var
-accum_new = accum + grad_with_shrinkage * grad_with_shrinkage
-linear += grad_with_shrinkage +
-    (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
-quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
-var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
-accum = accum_new
-END
-}
-op {
-  graph_op_name: "ApplyGradientDescent"
-  endpoint {
-    name: "ApplyGradientDescent"
-  }
-  summary: "Update \'*var\' by subtracting \'alpha\' * \'delta\' from it."
-}
-op {
-  graph_op_name: "ApplyMomentum"
-  endpoint {
-    name: "ApplyMomentum"
-  }
-  summary: "Update \'*var\' according to the momentum scheme. Set use_nesterov = True if you"
-  description: <<END
-want to use Nesterov momentum.
-
-accum = accum * momentum + grad
-var -= lr * accum
-END
-}
-op {
-  graph_op_name: "ApplyProximalAdagrad"
-  endpoint {
-    name: "ApplyProximalAdagrad"
-  }
-  summary: "Update \'*var\' and \'*accum\' according to FOBOS with Adagrad learning rate."
-  description: <<END
-accum += grad * grad
-prox_v = var - lr * grad * (1 / sqrt(accum))
-var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}
-END
-}
-op {
-  graph_op_name: "ApplyProximalGradientDescent"
-  endpoint {
-    name: "ApplyProximalGradientDescent"
-  }
-  summary: "Update \'*var\' as FOBOS algorithm with fixed learning rate."
-  description: <<END
-prox_v = var - alpha * delta
-var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}
-END
-}
-op {
-  graph_op_name: "ApplyRMSProp"
-  endpoint {
-    name: "ApplyRMSProp"
-  }
-  summary: "Update \'*var\' according to the RMSProp algorithm."
-  description: <<END
-Note that in dense implementation of this algorithm, ms and mom will
-update even if the grad is zero, but in this sparse implementation, ms
-and mom will not update in iterations during which the grad is zero.
-
-mean_square = decay * mean_square + (1-decay) * gradient ** 2
-Delta = learning_rate * gradient / sqrt(mean_square + epsilon)
-
-ms <- rho * ms_{t-1} + (1-rho) * grad * grad
-mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
-var <- var - mom
-END
-}
-op {
-  graph_op_name: "ApproximateEqual"
-  endpoint {
-    name: "ApproximateEqual"
-  }
-  summary: "Returns the truth value of abs(x-y) < tolerance element-wise."
-}
-op {
-  graph_op_name: "ArgMax"
-  endpoint {
-    name: "ArgMax"
-  }
-  summary: "Returns the index with the largest value across dimensions of a tensor."
-  description: <<END
-Note that in case of ties the identity of the return value is not guaranteed.
-END
-}
-op {
-  graph_op_name: "ArgMin"
-  endpoint {
-    name: "ArgMin"
-  }
-  summary: "Returns the index with the smallest value across dimensions of a tensor."
-  description: <<END
-Note that in case of ties the identity of the return value is not guaranteed.
-END
-}
-op {
-  graph_op_name: "AsString"
-  endpoint {
-    name: "AsString"
-  }
-  summary: "Converts each entry in the given tensor to strings.  Supports many numeric"
-  description: <<END
-types and boolean.
-END
-}
-op {
-  graph_op_name: "Asin"
-  endpoint {
-    name: "Asin"
-  }
-  summary: "Computes asin of x element-wise."
-}
-op {
-  graph_op_name: "Asinh"
-  endpoint {
-    name: "Asinh"
-  }
-  summary: "Computes inverse hyperbolic sine of x element-wise."
-}
-op {
-  graph_op_name: "Assert"
-  endpoint {
-    name: "Assert"
-  }
-  summary: "Asserts that the given condition is true."
-  description: <<END
-If `condition` evaluates to false, print the list of tensors in `data`.
-`summarize` determines how many entries of the tensors to print.
-END
-}
-op {
-  graph_op_name: "Assign"
-  endpoint {
-    name: "Assign"
-  }
-  summary: "Update \'ref\' by assigning \'value\' to it."
-  description: <<END
-This operation outputs "ref" after the assignment is done.
-This makes it easier to chain operations that need to use the reset value.
-END
-}
-op {
-  graph_op_name: "AssignAdd"
-  endpoint {
-    name: "AssignAdd"
-  }
-  summary: "Update \'ref\' by adding \'value\' to it."
-  description: <<END
-This operation outputs "ref" after the update is done.
-This makes it easier to chain operations that need to use the reset value.
-END
-}
-op {
-  graph_op_name: "AssignSub"
-  endpoint {
-    name: "AssignSub"
-  }
-  summary: "Update \'ref\' by subtracting \'value\' from it."
-  description: <<END
-This operation outputs "ref" after the update is done.
-This makes it easier to chain operations that need to use the reset value.
-END
-}
-op {
-  graph_op_name: "Atan"
-  endpoint {
-    name: "Atan"
-  }
-  summary: "Computes atan of x element-wise."
-}
-op {
-  graph_op_name: "Atan2"
-  endpoint {
-    name: "Atan2"
-  }
-  summary: "Computes arctangent of `y/x` element-wise, respecting signs of the arguments."
-  description: <<END
-This is the angle \( \theta \in [-\pi, \pi] \) such that
-\[ x = r \cos(\theta) \]
-and
-\[ y = r \sin(\theta) \]
-where \(r = \sqrt(x^2 + y^2) \).
-END
-}
-op {
-  graph_op_name: "Atanh"
-  endpoint {
-    name: "Atanh"
-  }
-  summary: "Computes inverse hyperbolic tangent of x element-wise."
-}
-op {
-  graph_op_name: "AudioSpectrogram"
-  endpoint {
-    name: "AudioSpectrogram"
-  }
-  summary: "Produces a visualization of audio data over time."
-  description: <<END
-Spectrograms are a standard way of representing audio information as a series of
-slices of frequency information, one slice for each window of time. By joining
-these together into a sequence, they form a distinctive fingerprint of the sound
-over time.
-
-This op expects to receive audio data as an input, stored as floats in the range
--1 to 1, together with a window width in samples, and a stride specifying how
-far to move the window between slices. From this it generates a three
-dimensional output. The lowest dimension has an amplitude value for each
-frequency during that time slice. The next dimension is time, with successive
-frequency slices. The final dimension is for the channels in the input, so a
-stereo audio input would have two here for example.
-
-This means the layout when converted and saved as an image is rotated 90 degrees
-clockwise from a typical spectrogram. Time is descending down the Y axis, and
-the frequency decreases from left to right.
-
-Each value in the result represents the square root of the sum of the real and
-imaginary parts of an FFT on the current window of samples. In this way, the
-lowest dimension represents the power of each frequency in the current window,
-and adjacent windows are concatenated in the next dimension.
-
-To get a more intuitive and visual look at what this operation does, you can run
-tensorflow/examples/wav_to_spectrogram to read in an audio file and save out the
-resulting spectrogram as a PNG image.
-END
-}
-op {
-  graph_op_name: "AudioSummary"
-  endpoint {
-    name: "AudioSummary"
-  }
-  summary: "Outputs a `Summary` protocol buffer with audio."
-  description: <<END
-The summary has up to `max_outputs` summary values containing audio. The
-audio is built from `tensor` which must be 3-D with shape `[batch_size,
-frames, channels]` or 2-D with shape `[batch_size, frames]`. The values are
-assumed to be in the range of `[-1.0, 1.0]` with a sample rate of `sample_rate`.
-
-The `tag` argument is a scalar `Tensor` of type `string`.  It is used to
-build the `tag` of the summary values:
-
-*  If `max_outputs` is 1, the summary value tag is '*tag*/audio'.
-*  If `max_outputs` is greater than 1, the summary value tags are
-   generated sequentially as '*tag*/audio/0', '*tag*/audio/1', etc.
-END
-}
-op {
-  graph_op_name: "AudioSummaryV2"
-  endpoint {
-    name: "AudioSummaryV2"
-  }
-  summary: "Outputs a `Summary` protocol buffer with audio."
-  description: <<END
-The summary has up to `max_outputs` summary values containing audio. The
-audio is built from `tensor` which must be 3-D with shape `[batch_size,
-frames, channels]` or 2-D with shape `[batch_size, frames]`. The values are
-assumed to be in the range of `[-1.0, 1.0]` with a sample rate of `sample_rate`.
-
-The `tag` argument is a scalar `Tensor` of type `string`.  It is used to
-build the `tag` of the summary values:
-
-*  If `max_outputs` is 1, the summary value tag is '*tag*/audio'.
-*  If `max_outputs` is greater than 1, the summary value tags are
-   generated sequentially as '*tag*/audio/0', '*tag*/audio/1', etc.
-END
-}
-op {
-  graph_op_name: "AvgPool"
-  endpoint {
-    name: "AvgPool"
-  }
-  summary: "Performs average pooling on the input."
-  description: <<END
-Each entry in `output` is the mean of the corresponding size `ksize`
-window in `value`.
-END
-}
-op {
-  graph_op_name: "AvgPool3D"
-  endpoint {
-    name: "AvgPool3D"
-  }
-  summary: "Performs 3D average pooling on the input."
-}
-op {
-  graph_op_name: "AvgPool3DGrad"
-  endpoint {
-    name: "AvgPool3DGrad"
-  }
-  summary: "Computes gradients of average pooling function."
-}
-op {
-  graph_op_name: "AvgPoolGrad"
-  endpoint {
-    name: "AvgPoolGrad"
-  }
-  summary: "Computes gradients of the average pooling function."
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_Abort.pbtxt b/tensorflow/core/api_def/base_api/api_def_Abort.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6dd923c512af8d38ec04ec1116cc5da1e97d7e92
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Abort.pbtxt
@@ -0,0 +1,16 @@
+op {
+  graph_op_name: "Abort"
+  attr {
+    name: "error_msg"
+    description: <<END
+A string which is the message associated with the exception.
+END
+  }
+  summary: "Raise a exception to abort the process when called."
+  description: <<END
+If exit_without_error is true, the process will exit normally,
+otherwise it will exit with a SIGABORT signal.
+
+Returns nothing but an exception.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Abs.pbtxt b/tensorflow/core/api_def/base_api/api_def_Abs.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..412891f4f4f97cb66e94db58bf089d105f4351f8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Abs.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "Abs"
+  summary: "Computes the absolute value of a tensor."
+  description: <<END
+Given a tensor `x`, this operation returns a tensor containing the absolute
+value of each element in `x`. For example, if x is an input element and y is
+an output element, this operation computes \\(y = |x|\\).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AccumulateNV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_AccumulateNV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2f20911d2d685ff129f02365a9d54e24ed724e0b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AccumulateNV2.pbtxt
@@ -0,0 +1,26 @@
+op {
+  graph_op_name: "AccumulateNV2"
+  in_arg {
+    name: "inputs"
+    description: <<END
+A list of `Tensor` objects, each with same shape and type.
+END
+  }
+  attr {
+    name: "shape"
+    description: <<END
+Shape of elements of `inputs`.
+END
+  }
+  summary: "Returns the element-wise sum of a list of tensors."
+  description: <<END
+`tf.accumulate_n_v2` performs the same operation as `tf.add_n`, but does not
+wait for all of its inputs to be ready before beginning to sum. This can
+save memory if inputs are ready at different times, since minimum temporary
+storage is proportional to the output size rather than the inputs size.
+
+Unlike the original `accumulate_n`, `accumulate_n_v2` is differentiable.
+
+Returns a `Tensor` of same shape and type as the elements of `inputs`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AccumulatorApplyGradient.pbtxt b/tensorflow/core/api_def/base_api/api_def_AccumulatorApplyGradient.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..25928a32ca03e45a211ca99aa97cf413036e27e0
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AccumulatorApplyGradient.pbtxt
@@ -0,0 +1,32 @@
+op {
+  graph_op_name: "AccumulatorApplyGradient"
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a accumulator.
+END
+  }
+  in_arg {
+    name: "local_step"
+    description: <<END
+The local_step value at which the gradient was computed.
+END
+  }
+  in_arg {
+    name: "gradient"
+    description: <<END
+A tensor of the gradient to be accumulated.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The data type of accumulated gradients. Needs to correspond to the type
+of the accumulator.
+END
+  }
+  summary: "Applies a gradient to a given accumulator."
+  description: <<END
+Does not add if local_step is lesser than the accumulator's global_step.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AccumulatorNumAccumulated.pbtxt b/tensorflow/core/api_def/base_api/api_def_AccumulatorNumAccumulated.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..270265a8040b3f70637f2ee3d50066c2ad0eca6b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AccumulatorNumAccumulated.pbtxt
@@ -0,0 +1,16 @@
+op {
+  graph_op_name: "AccumulatorNumAccumulated"
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to an accumulator.
+END
+  }
+  out_arg {
+    name: "num_accumulated"
+    description: <<END
+The number of gradients aggregated in the given accumulator.
+END
+  }
+  summary: "Returns the number of gradients aggregated in the given accumulators."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AccumulatorSetGlobalStep.pbtxt b/tensorflow/core/api_def/base_api/api_def_AccumulatorSetGlobalStep.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b08a0afbc2d21676109b5c9ffafb6e0fc5701bda
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AccumulatorSetGlobalStep.pbtxt
@@ -0,0 +1,20 @@
+op {
+  graph_op_name: "AccumulatorSetGlobalStep"
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to an accumulator.
+END
+  }
+  in_arg {
+    name: "new_global_step"
+    description: <<END
+The new global_step value to set.
+END
+  }
+  summary: "Updates the accumulator with a new value for global_step."
+  description: <<END
+Logs warning if the accumulator's value is already higher than
+new_global_step.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AccumulatorTakeGradient.pbtxt b/tensorflow/core/api_def/base_api/api_def_AccumulatorTakeGradient.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1e53de7c6fd990081c2ed14f0dc2c1117aae0527
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AccumulatorTakeGradient.pbtxt
@@ -0,0 +1,36 @@
+op {
+  graph_op_name: "AccumulatorTakeGradient"
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to an accumulator.
+END
+  }
+  in_arg {
+    name: "num_required"
+    description: <<END
+Number of gradients required before we return an aggregate.
+END
+  }
+  out_arg {
+    name: "average"
+    description: <<END
+The average of the accumulated gradients.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The data type of accumulated gradients. Needs to correspond to the type
+of the accumulator.
+END
+  }
+  summary: "Extracts the average gradient in the given ConditionalAccumulator."
+  description: <<END
+The op blocks until sufficient (i.e., more than num_required)
+gradients have been accumulated.  If the accumulator has already
+aggregated more than num_required gradients, it returns the average of
+the accumulated gradients.  Also automatically increments the recorded
+global_step in the accumulator by 1, and resets the aggregate to 0.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Acos.pbtxt b/tensorflow/core/api_def/base_api/api_def_Acos.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2184b644b230186a0b379d129052c4d75b6fb4a2
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Acos.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Acos"
+  summary: "Computes acos of x element-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Acosh.pbtxt b/tensorflow/core/api_def/base_api/api_def_Acosh.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..da77e814988d88a91e6f0fee717c88150a15ac97
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Acosh.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Acosh"
+  summary: "Computes inverse hyperbolic cosine of x element-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Add.pbtxt b/tensorflow/core/api_def/base_api/api_def_Add.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7a408af380a36bfd335d2f00f64a4388c36aca4e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Add.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "Add"
+  summary: "Returns x + y element-wise."
+  description: <<END
+*NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AddManySparseToTensorsMap.pbtxt b/tensorflow/core/api_def/base_api/api_def_AddManySparseToTensorsMap.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9e5726a2d3e629ae8bc5b49e806935ee135e4fd9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AddManySparseToTensorsMap.pbtxt
@@ -0,0 +1,68 @@
+op {
+  graph_op_name: "AddManySparseToTensorsMap"
+  in_arg {
+    name: "sparse_indices"
+    description: <<END
+2-D.  The `indices` of the minibatch `SparseTensor`.
+`sparse_indices[:, 0]` must be ordered values in `[0, N)`.
+END
+  }
+  in_arg {
+    name: "sparse_values"
+    description: <<END
+1-D.  The `values` of the minibatch `SparseTensor`.
+END
+  }
+  in_arg {
+    name: "sparse_shape"
+    description: <<END
+1-D.  The `shape` of the minibatch `SparseTensor`.
+The minibatch size `N == sparse_shape[0]`.
+END
+  }
+  out_arg {
+    name: "sparse_handles"
+    description: <<END
+1-D.  The handles of the `SparseTensor` now stored in the
+`SparseTensorsMap`.  Shape: `[N]`.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+The container name for the `SparseTensorsMap` created by this op.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+The shared name for the `SparseTensorsMap` created by this op.
+If blank, the new Operation's unique name is used.
+END
+  }
+  summary: "Add an `N`-minibatch `SparseTensor` to a `SparseTensorsMap`, return `N` handles."
+  description: <<END
+A `SparseTensor` of rank `R` is represented by three tensors: `sparse_indices`,
+`sparse_values`, and `sparse_shape`, where
+
+```sparse_indices.shape[1] == sparse_shape.shape[0] == R```
+
+An `N`-minibatch of `SparseTensor` objects is represented as a `SparseTensor`
+having a first `sparse_indices` column taking values between `[0, N)`, where
+the minibatch size `N == sparse_shape[0]`.
+
+The input `SparseTensor` must have rank `R` greater than 1, and the first
+dimension is treated as the minibatch dimension.  Elements of the `SparseTensor`
+must be sorted in increasing order of this first dimension.  The stored
+`SparseTensor` objects pointed to by each row of the output `sparse_handles`
+will have rank `R-1`.
+
+The `SparseTensor` values can then be read out as part of a minibatch by passing
+the given keys as vector elements to `TakeManySparseFromTensorsMap`.  To ensure
+the correct `SparseTensorsMap` is accessed, ensure that the same
+`container` and `shared_name` are passed to that Op.  If no `shared_name`
+is provided here, instead use the *name* of the Operation created by calling
+`AddManySparseToTensorsMap` as the `shared_name` passed to
+`TakeManySparseFromTensorsMap`.  Ensure the Operations are colocated.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AddN.pbtxt b/tensorflow/core/api_def/base_api/api_def_AddN.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..64677763a498c89368a510186cede3a553a31df4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AddN.pbtxt
@@ -0,0 +1,10 @@
+op {
+  graph_op_name: "AddN"
+  in_arg {
+    name: "inputs"
+    description: <<END
+Must all be the same size and shape.
+END
+  }
+  summary: "Add all input tensors element wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AddSparseToTensorsMap.pbtxt b/tensorflow/core/api_def/base_api/api_def_AddSparseToTensorsMap.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0438eac6549d974773e156ad00513671431e92a7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AddSparseToTensorsMap.pbtxt
@@ -0,0 +1,58 @@
+op {
+  graph_op_name: "AddSparseToTensorsMap"
+  in_arg {
+    name: "sparse_indices"
+    description: <<END
+2-D.  The `indices` of the `SparseTensor`.
+END
+  }
+  in_arg {
+    name: "sparse_values"
+    description: <<END
+1-D.  The `values` of the `SparseTensor`.
+END
+  }
+  in_arg {
+    name: "sparse_shape"
+    description: <<END
+1-D.  The `shape` of the `SparseTensor`.
+END
+  }
+  out_arg {
+    name: "sparse_handle"
+    description: <<END
+0-D.  The handle of the `SparseTensor` now stored in the
+`SparseTensorsMap`.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+The container name for the `SparseTensorsMap` created by this op.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+The shared name for the `SparseTensorsMap` created by this op.
+If blank, the new Operation's unique name is used.
+END
+  }
+  summary: "Add a `SparseTensor` to a `SparseTensorsMap` return its handle."
+  description: <<END
+A `SparseTensor` is represented by three tensors: `sparse_indices`,
+`sparse_values`, and `sparse_shape`.
+
+This operator takes the given `SparseTensor` and adds it to a container
+object (a `SparseTensorsMap`).  A unique key within this container is generated
+in the form of an `int64`, and this is the value that is returned.
+
+The `SparseTensor` can then be read out as part of a minibatch by passing
+the key as a vector element to `TakeManySparseFromTensorsMap`.  To ensure
+the correct `SparseTensorsMap` is accessed, ensure that the same
+`container` and `shared_name` are passed to that Op.  If no `shared_name`
+is provided here, instead use the *name* of the Operation created by calling
+`AddSparseToTensorsMap` as the `shared_name` passed to
+`TakeManySparseFromTensorsMap`.  Ensure the Operations are colocated.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AddV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_AddV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1e4db21151ec50b66b1befe34ac29c714e5d1ff2
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AddV2.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "AddV2"
+  summary: "Returns x + y element-wise."
+  description: <<END
+*NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AdjustContrast.pbtxt b/tensorflow/core/api_def/base_api/api_def_AdjustContrast.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..45988d7e36196e401093d584082d73e94dc3df3b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AdjustContrast.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "AdjustContrast"
+  summary: "Deprecated. Disallowed in GraphDef version >= 2."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AdjustContrastv2.pbtxt b/tensorflow/core/api_def/base_api/api_def_AdjustContrastv2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..429a5e4434e011d1ba43847b9abf8877b4d41e7a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AdjustContrastv2.pbtxt
@@ -0,0 +1,36 @@
+op {
+  graph_op_name: "AdjustContrastv2"
+  endpoint {
+    name: "AdjustContrast"
+  }
+  in_arg {
+    name: "images"
+    description: <<END
+Images to adjust.  At least 3-D.
+END
+  }
+  in_arg {
+    name: "contrast_factor"
+    description: <<END
+A float multiplier for adjusting contrast.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The contrast-adjusted image or images.
+END
+  }
+  summary: "Adjust the contrast of one or more images."
+  description: <<END
+`images` is a tensor of at least 3 dimensions.  The last 3 dimensions are
+interpreted as `[height, width, channels]`.  The other dimensions only
+represent a collection of images, such as `[batch, height, width, channels].`
+
+Contrast is adjusted independently for each channel of each image.
+
+For each channel, the Op first computes the mean of the image pixels in the
+channel and then adjusts each component of each pixel to
+`(x - mean) * contrast_factor + mean`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AdjustHue.pbtxt b/tensorflow/core/api_def/base_api/api_def_AdjustHue.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bfaf676860134f9af407a7a94b34d257eb4cf96b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AdjustHue.pbtxt
@@ -0,0 +1,30 @@
+op {
+  graph_op_name: "AdjustHue"
+  in_arg {
+    name: "images"
+    description: <<END
+Images to adjust.  At least 3-D.
+END
+  }
+  in_arg {
+    name: "delta"
+    description: <<END
+A float delta to add to the hue.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The hue-adjusted image or images.
+END
+  }
+  summary: "Adjust the hue of one or more images."
+  description: <<END
+`images` is a tensor of at least 3 dimensions.  The last dimension is
+interpretted as channels, and must be three.
+
+The input image is considered in the RGB colorspace. Conceptually, the RGB
+colors are first mapped into HSV. A delta is then applied all the hue values,
+and then remapped back to RGB colorspace.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AdjustSaturation.pbtxt b/tensorflow/core/api_def/base_api/api_def_AdjustSaturation.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..97be0fda11f143a92d6d4f6cb909f00c1cee7fb0
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AdjustSaturation.pbtxt
@@ -0,0 +1,30 @@
+op {
+  graph_op_name: "AdjustSaturation"
+  in_arg {
+    name: "images"
+    description: <<END
+Images to adjust.  At least 3-D.
+END
+  }
+  in_arg {
+    name: "scale"
+    description: <<END
+A float scale to add to the saturation.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The hue-adjusted image or images.
+END
+  }
+  summary: "Adjust the saturation of one or more images."
+  description: <<END
+`images` is a tensor of at least 3 dimensions.  The last dimension is
+interpretted as channels, and must be three.
+
+The input image is considered in the RGB colorspace. Conceptually, the RGB
+colors are first mapped into HSV. A scale is then applied all the saturation
+values, and then remapped back to RGB colorspace.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_All.pbtxt b/tensorflow/core/api_def/base_api/api_def_All.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..623389988a3257cd8fbe6d96d862343f976f6b55
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_All.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "All"
+  endpoint {
+    name: "All"
+  }
+  endpoint {
+    name: "ReduceAll"
+  }
+  in_arg {
+    name: "input"
+    description: <<END
+The tensor to reduce.
+END
+  }
+  in_arg {
+    name: "reduction_indices"
+    rename_to: "axis"
+    description: <<END
+The dimensions to reduce. Must be in the range
+`[-rank(input), rank(input))`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The reduced tensor.
+END
+  }
+  attr {
+    name: "keep_dims"
+    description: <<END
+If true, retain reduced dimensions with length 1.
+END
+  }
+  summary: "Computes the \"logical and\" of elements across dimensions of a tensor."
+  description: <<END
+Reduces `input` along the dimensions given in `reduction_indices`. Unless
+`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+`reduction_indices`. If `keep_dims` is true, the reduced dimensions are
+retained with length 1.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AllCandidateSampler.pbtxt b/tensorflow/core/api_def/base_api/api_def_AllCandidateSampler.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..38b8e2bfbababa717f534300986f54951e357fde
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AllCandidateSampler.pbtxt
@@ -0,0 +1,80 @@
+op {
+  graph_op_name: "AllCandidateSampler"
+  in_arg {
+    name: "true_classes"
+    description: <<END
+A batch_size * num_true matrix, in which each row contains the
+IDs of the num_true target_classes in the corresponding original label.
+END
+  }
+  out_arg {
+    name: "sampled_candidates"
+    description: <<END
+A vector of length num_sampled, in which each element is
+the ID of a sampled candidate.
+END
+  }
+  out_arg {
+    name: "true_expected_count"
+    description: <<END
+A batch_size * num_true matrix, representing
+the number of times each candidate is expected to occur in a batch
+of sampled candidates. If unique=true, then this is a probability.
+END
+  }
+  out_arg {
+    name: "sampled_expected_count"
+    description: <<END
+A vector of length num_sampled, for each sampled
+candidate representing the number of times the candidate is expected
+to occur in a batch of sampled candidates.  If unique=true, then this is a
+probability.
+END
+  }
+  attr {
+    name: "num_true"
+    description: <<END
+Number of true labels per context.
+END
+  }
+  attr {
+    name: "num_sampled"
+    description: <<END
+Number of candidates to produce.
+END
+  }
+  attr {
+    name: "unique"
+    description: <<END
+If unique is true, we sample with rejection, so that all sampled
+candidates in a batch are unique. This requires some approximation to
+estimate the post-rejection sampling probabilities.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either seed or seed2 are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+An second seed to avoid seed collision.
+END
+  }
+  summary: "Generates labels for candidate sampling with a learned unigram distribution."
+  description: <<END
+See explanations of candidate sampling and the data formats at
+go/candidate-sampling.
+
+For each batch, this op picks a single set of sampled candidate labels.
+
+The advantages of sampling candidates per-batch are simplicity and the
+possibility of efficient dense matrix multiplication. The disadvantage is that
+the sampled candidates must be chosen independently of the context and of the
+true labels.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Angle.pbtxt b/tensorflow/core/api_def/base_api/api_def_Angle.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a26e5e244719a6f40edfa93a0c863b47f68cdaf5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Angle.pbtxt
@@ -0,0 +1,23 @@
+op {
+  graph_op_name: "Angle"
+  summary: "Returns the argument of a complex number."
+  description: <<END
+Given a tensor `input` of complex numbers, this operation returns a tensor of
+type `float` that is the argument of each element in `input`. All elements in
+`input` must be complex numbers of the form \\(a + bj\\), where *a*
+is the real part and *b* is the imaginary part.
+
+The argument returned by this operation is of the form \\(atan2(b, a)\\).
+
+For example:
+
+```
+# tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
+tf.angle(input) ==> [2.0132, 1.056]
+```
+
+@compatibility(numpy)
+Equivalent to np.angle.
+@end_compatibility
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Any.pbtxt b/tensorflow/core/api_def/base_api/api_def_Any.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..09fd4e0b6036447dfe355ff56da29e276de62f2b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Any.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "Any"
+  endpoint {
+    name: "Any"
+  }
+  endpoint {
+    name: "ReduceAny"
+  }
+  in_arg {
+    name: "input"
+    description: <<END
+The tensor to reduce.
+END
+  }
+  in_arg {
+    name: "reduction_indices"
+    rename_to: "axis"
+    description: <<END
+The dimensions to reduce. Must be in the range
+`[-rank(input), rank(input))`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The reduced tensor.
+END
+  }
+  attr {
+    name: "keep_dims"
+    description: <<END
+If true, retain reduced dimensions with length 1.
+END
+  }
+  summary: "Computes the \"logical or\" of elements across dimensions of a tensor."
+  description: <<END
+Reduces `input` along the dimensions given in `reduction_indices`. Unless
+`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+`reduction_indices`. If `keep_dims` is true, the reduced dimensions are
+retained with length 1.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ApplyAdadelta.pbtxt b/tensorflow/core/api_def/base_api/api_def_ApplyAdadelta.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d3aa32ba9fa1a589d84a735ce0b958a4d4272041
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ApplyAdadelta.pbtxt
@@ -0,0 +1,65 @@
+op {
+  graph_op_name: "ApplyAdadelta"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum_update"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "rho"
+    description: <<END
+Decay factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "epsilon"
+    description: <<END
+Constant factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, updating of the var, accum and update_accum tensors will be protected by
+a lock; otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Update \'*var\' according to the adadelta scheme."
+  description: <<END
+accum = rho() * accum + (1 - rho()) * grad.square();
+update = (update_accum + epsilon).sqrt() * (accum + epsilon()).rsqrt() * grad;
+update_accum = rho() * update_accum + (1 - rho()) * update.square();
+var -= update;
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ApplyAdagrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_ApplyAdagrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..057786b6aa4ea741d09d7b5534692ecbd52dce00
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ApplyAdagrad.pbtxt
@@ -0,0 +1,46 @@
+op {
+  graph_op_name: "ApplyAdagrad"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var and accum tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update \'*var\' according to the adagrad scheme."
+  description: <<END
+accum += grad * grad
+var -= lr * grad * (1 / sqrt(accum))
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ApplyAdagradDA.pbtxt b/tensorflow/core/api_def/base_api/api_def_ApplyAdagradDA.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1453bb558dfcf2db2c3a881b71d10a38b1999322
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ApplyAdagradDA.pbtxt
@@ -0,0 +1,65 @@
+op {
+  graph_op_name: "ApplyAdagradDA"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "gradient_accumulator"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "gradient_squared_accumulator"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "global_step"
+    description: <<END
+Training step number. Must be a scalar.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, updating of the var and accum tensors will be protected by
+a lock; otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Update \'*var\' according to the proximal adagrad scheme."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ApplyAdam.pbtxt b/tensorflow/core/api_def/base_api/api_def_ApplyAdam.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c2858a1bfbb5a30e5e72bcfad694f696e08d2346
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ApplyAdam.pbtxt
@@ -0,0 +1,90 @@
+op {
+  graph_op_name: "ApplyAdam"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "m"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "v"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "beta1_power"
+    description: <<END
+Must be a scalar.
+END
+  }
+  in_arg {
+    name: "beta2_power"
+    description: <<END
+Must be a scalar.
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "beta1"
+    description: <<END
+Momentum factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "beta2"
+    description: <<END
+Momentum factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "epsilon"
+    description: <<END
+Ridge term. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var, m, and v tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  attr {
+    name: "use_nesterov"
+    description: <<END
+If `True`, uses the nesterov update.
+END
+  }
+  summary: "Update \'*var\' according to the Adam algorithm."
+  description: <<END
+lr_t <- learning_rate * sqrt(1 - beta2^t) / (1 - beta1^t)
+m_t <- beta1 * m_{t-1} + (1 - beta1) * g_t
+v_t <- beta2 * v_{t-1} + (1 - beta2) * g_t * g_t
+variable <- variable - lr_t * m_t / (sqrt(v_t) + epsilon)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ApplyCenteredRMSProp.pbtxt b/tensorflow/core/api_def/base_api/api_def_ApplyCenteredRMSProp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c88d18d3b2050e428a59aa5f49d12bcc266cd80a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ApplyCenteredRMSProp.pbtxt
@@ -0,0 +1,86 @@
+op {
+  graph_op_name: "ApplyCenteredRMSProp"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "mg"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "ms"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "mom"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "rho"
+    description: <<END
+Decay rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "epsilon"
+    description: <<END
+Ridge term. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var, mg, ms, and mom tensors is
+protected by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update \'*var\' according to the centered RMSProp algorithm."
+  description: <<END
+The centered RMSProp algorithm uses an estimate of the centered second moment
+(i.e., the variance) for normalization, as opposed to regular RMSProp, which
+uses the (uncentered) second moment. This often helps with training, but is
+slightly more expensive in terms of computation and memory.
+
+Note that in dense implementation of this algorithm, mg, ms, and mom will
+update even if the grad is zero, but in this sparse implementation, mg, ms,
+and mom will not update in iterations during which the grad is zero.
+
+mean_square = decay * mean_square + (1-decay) * gradient ** 2
+mean_grad = decay * mean_grad + (1-decay) * gradient
+
+Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2)
+
+mg <- rho * mg_{t-1} + (1-rho) * grad
+ms <- rho * ms_{t-1} + (1-rho) * grad * grad
+mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms - mg * mg + epsilon)
+var <- var - mom
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ApplyFtrl.pbtxt b/tensorflow/core/api_def/base_api/api_def_ApplyFtrl.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..77da9e4d510b0d5d57c7e46fae044a55f87ef828
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ApplyFtrl.pbtxt
@@ -0,0 +1,73 @@
+op {
+  graph_op_name: "ApplyFtrl"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "linear"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regulariation. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 regulariation. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "lr_power"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var and accum tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update \'*var\' according to the Ftrl-proximal scheme."
+  description: <<END
+accum_new = accum + grad * grad
+linear += grad + (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
+quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
+var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
+accum = accum_new
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ApplyFtrlV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_ApplyFtrlV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..974f3adc196129f9fe83d098c22dc3cd237263d6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ApplyFtrlV2.pbtxt
@@ -0,0 +1,75 @@
+op {
+  graph_op_name: "ApplyFtrlV2"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "linear"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regulariation. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 shrinkage regulariation. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "lr_power"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var and accum tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update \'*var\' according to the Ftrl-proximal scheme."
+  description: <<END
+grad_with_shrinkage = grad + 2 * l2_shrinkage * var
+accum_new = accum + grad_with_shrinkage * grad_with_shrinkage
+linear += grad_with_shrinkage +
+    (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
+quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
+var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
+accum = accum_new
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ApplyGradientDescent.pbtxt b/tensorflow/core/api_def/base_api/api_def_ApplyGradientDescent.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2f38ebd1b8c89a1a65368d3da38cead73225ada5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ApplyGradientDescent.pbtxt
@@ -0,0 +1,35 @@
+op {
+  graph_op_name: "ApplyGradientDescent"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "alpha"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "delta"
+    description: <<END
+The change.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, the subtraction will be protected by a lock;
+otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Update \'*var\' by subtracting \'alpha\' * \'delta\' from it."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ApplyMomentum.pbtxt b/tensorflow/core/api_def/base_api/api_def_ApplyMomentum.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..55326fd35cf9c96c23da422896f8fede1a276e5b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ApplyMomentum.pbtxt
@@ -0,0 +1,62 @@
+op {
+  graph_op_name: "ApplyMomentum"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "momentum"
+    description: <<END
+Momentum. Must be a scalar.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var and accum tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  attr {
+    name: "use_nesterov"
+    description: <<END
+If `True`, the tensor passed to compute grad will be
+var - lr * momentum * accum, so in the end, the var you get is actually
+var - lr * momentum * accum.
+END
+  }
+  summary: "Update \'*var\' according to the momentum scheme. Set use_nesterov = True if you"
+  description: <<END
+want to use Nesterov momentum.
+
+accum = accum * momentum + grad
+var -= lr * accum
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ApplyProximalAdagrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_ApplyProximalAdagrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a683ba12a45716dcacef4ae2deef5952ec2293da
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ApplyProximalAdagrad.pbtxt
@@ -0,0 +1,58 @@
+op {
+  graph_op_name: "ApplyProximalAdagrad"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, updating of the var and accum tensors will be protected by
+a lock; otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Update \'*var\' and \'*accum\' according to FOBOS with Adagrad learning rate."
+  description: <<END
+accum += grad * grad
+prox_v = var - lr * grad * (1 / sqrt(accum))
+var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ApplyProximalGradientDescent.pbtxt b/tensorflow/core/api_def/base_api/api_def_ApplyProximalGradientDescent.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7914c60b7137320b5ee81e7afb30e8a884d71fe6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ApplyProximalGradientDescent.pbtxt
@@ -0,0 +1,51 @@
+op {
+  graph_op_name: "ApplyProximalGradientDescent"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "alpha"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "delta"
+    description: <<END
+The change.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, the subtraction will be protected by a lock;
+otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Update \'*var\' as FOBOS algorithm with fixed learning rate."
+  description: <<END
+prox_v = var - alpha * delta
+var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ApplyRMSProp.pbtxt b/tensorflow/core/api_def/base_api/api_def_ApplyRMSProp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8ecf89c0f4a86c09b87338843f8836e5c33aa50c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ApplyRMSProp.pbtxt
@@ -0,0 +1,72 @@
+op {
+  graph_op_name: "ApplyRMSProp"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "ms"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "mom"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "rho"
+    description: <<END
+Decay rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "epsilon"
+    description: <<END
+Ridge term. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var, ms, and mom tensors is protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update \'*var\' according to the RMSProp algorithm."
+  description: <<END
+Note that in dense implementation of this algorithm, ms and mom will
+update even if the grad is zero, but in this sparse implementation, ms
+and mom will not update in iterations during which the grad is zero.
+
+mean_square = decay * mean_square + (1-decay) * gradient ** 2
+Delta = learning_rate * gradient / sqrt(mean_square + epsilon)
+
+ms <- rho * ms_{t-1} + (1-rho) * grad * grad
+mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
+var <- var - mom
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ApproximateEqual.pbtxt b/tensorflow/core/api_def/base_api/api_def_ApproximateEqual.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8842fa9bbcec584895efc7216983a121c9b71246
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ApproximateEqual.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ApproximateEqual"
+  summary: "Returns the truth value of abs(x-y) < tolerance element-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ArgMax.pbtxt b/tensorflow/core/api_def/base_api/api_def_ArgMax.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0cc81d1c8b7194cabaf7f7c3329b4984d4de0276
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ArgMax.pbtxt
@@ -0,0 +1,15 @@
+op {
+  graph_op_name: "ArgMax"
+  in_arg {
+    name: "dimension"
+    description: <<END
+int32 or int64, must be in the range `[-rank(input), rank(input))`.
+Describes which dimension of the input Tensor to reduce across. For vectors,
+use dimension = 0.
+END
+  }
+  summary: "Returns the index with the largest value across dimensions of a tensor."
+  description: <<END
+Note that in case of ties the identity of the return value is not guaranteed.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ArgMin.pbtxt b/tensorflow/core/api_def/base_api/api_def_ArgMin.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fb7410c5fd6e8a13f39cb633e44a0f89a3ba5b87
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ArgMin.pbtxt
@@ -0,0 +1,15 @@
+op {
+  graph_op_name: "ArgMin"
+  in_arg {
+    name: "dimension"
+    description: <<END
+int32 or int64, must be in the range `[-rank(input), rank(input))`.
+Describes which dimension of the input Tensor to reduce across. For vectors,
+use dimension = 0.
+END
+  }
+  summary: "Returns the index with the smallest value across dimensions of a tensor."
+  description: <<END
+Note that in case of ties the identity of the return value is not guaranteed.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AsString.pbtxt b/tensorflow/core/api_def/base_api/api_def_AsString.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5f2bca8eda86056d77a0274a76b44555bfc33220
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AsString.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "AsString"
+  attr {
+    name: "precision"
+    description: <<END
+The post-decimal precision to use for floating point numbers.
+Only used if precision > -1.
+END
+  }
+  attr {
+    name: "scientific"
+    description: <<END
+Use scientific notation for floating point numbers.
+END
+  }
+  attr {
+    name: "shortest"
+    description: <<END
+Use shortest representation (either scientific or standard) for
+floating point numbers.
+END
+  }
+  attr {
+    name: "width"
+    description: <<END
+Pad pre-decimal numbers to this width.
+Applies to both floating point and integer numbers.
+Only used if width > -1.
+END
+  }
+  attr {
+    name: "fill"
+    description: <<END
+The value to pad if width > -1.  If empty, pads with spaces.
+Another typical value is '0'.  String cannot be longer than 1 character.
+END
+  }
+  summary: "Converts each entry in the given tensor to strings.  Supports many numeric"
+  description: <<END
+types and boolean.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Asin.pbtxt b/tensorflow/core/api_def/base_api/api_def_Asin.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..19e1b144214e65b928309bd8e1075a4f35528d2b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Asin.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Asin"
+  summary: "Computes asin of x element-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Asinh.pbtxt b/tensorflow/core/api_def/base_api/api_def_Asinh.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..20f4dab8613b1bb4418ae2754f39e327bb484a11
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Asinh.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Asinh"
+  summary: "Computes inverse hyperbolic sine of x element-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Assert.pbtxt b/tensorflow/core/api_def/base_api/api_def_Assert.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..90e5df814936f4851bd515d1faa34eb206197181
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Assert.pbtxt
@@ -0,0 +1,26 @@
+op {
+  graph_op_name: "Assert"
+  in_arg {
+    name: "condition"
+    description: <<END
+The condition to evaluate.
+END
+  }
+  in_arg {
+    name: "data"
+    description: <<END
+The tensors to print out when condition is false.
+END
+  }
+  attr {
+    name: "summarize"
+    description: <<END
+Print this many entries of each tensor.
+END
+  }
+  summary: "Asserts that the given condition is true."
+  description: <<END
+If `condition` evaluates to false, print the list of tensors in `data`.
+`summarize` determines how many entries of the tensors to print.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Assign.pbtxt b/tensorflow/core/api_def/base_api/api_def_Assign.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4ae9b49f49c1ec0e74305653cbc45ac8344b5bac
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Assign.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "Assign"
+  in_arg {
+    name: "ref"
+    description: <<END
+Should be from a `Variable` node. May be uninitialized.
+END
+  }
+  in_arg {
+    name: "value"
+    description: <<END
+The value to be assigned to the variable.
+END
+  }
+  out_arg {
+    name: "output_ref"
+    description: <<END
+= Same as "ref".  Returned as a convenience for operations that want
+to use the new value after the variable has been reset.
+END
+  }
+  attr {
+    name: "validate_shape"
+    description: <<END
+If true, the operation will validate that the shape
+of 'value' matches the shape of the Tensor being assigned to.  If false,
+'ref' will take on the shape of 'value'.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, the assignment will be protected by a lock;
+otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Update \'ref\' by assigning \'value\' to it."
+  description: <<END
+This operation outputs "ref" after the assignment is done.
+This makes it easier to chain operations that need to use the reset value.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AssignAdd.pbtxt b/tensorflow/core/api_def/base_api/api_def_AssignAdd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d09ec5e196359202ccdb73ca4db504a8a3901b7f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AssignAdd.pbtxt
@@ -0,0 +1,34 @@
+op {
+  graph_op_name: "AssignAdd"
+  in_arg {
+    name: "ref"
+    description: <<END
+Should be from a `Variable` node.
+END
+  }
+  in_arg {
+    name: "value"
+    description: <<END
+The value to be added to the variable.
+END
+  }
+  out_arg {
+    name: "output_ref"
+    description: <<END
+= Same as "ref".  Returned as a convenience for operations that want
+to use the new value after the variable has been updated.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, the addition will be protected by a lock;
+otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Update \'ref\' by adding \'value\' to it."
+  description: <<END
+This operation outputs "ref" after the update is done.
+This makes it easier to chain operations that need to use the reset value.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AssignAddVariableOp.pbtxt b/tensorflow/core/api_def/base_api/api_def_AssignAddVariableOp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5d21d7bab699ff481c65ed44eb9bf66ec14ea387
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AssignAddVariableOp.pbtxt
@@ -0,0 +1,29 @@
+op {
+  graph_op_name: "AssignAddVariableOp"
+  in_arg {
+    name: "resource"
+    description: <<END
+handle to the resource in which to store the variable.
+END
+  }
+  in_arg {
+    name: "value"
+    description: <<END
+the value by which the variable will be incremented.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+the dtype of the value.
+END
+  }
+  summary: "Adds a value to the current value of a variable."
+  description: <<END
+Any ReadVariableOp which depends directly or indirectly on this assign is
+guaranteed to see the incremented value or a subsequent newer one.
+
+Outputs the incremented value, which can be used to totally order the
+increments to this variable.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AssignSub.pbtxt b/tensorflow/core/api_def/base_api/api_def_AssignSub.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..191a5c34fea6ec1a1b85c3135372ba4b91f47909
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AssignSub.pbtxt
@@ -0,0 +1,34 @@
+op {
+  graph_op_name: "AssignSub"
+  in_arg {
+    name: "ref"
+    description: <<END
+Should be from a `Variable` node.
+END
+  }
+  in_arg {
+    name: "value"
+    description: <<END
+The value to be subtracted to the variable.
+END
+  }
+  out_arg {
+    name: "output_ref"
+    description: <<END
+= Same as "ref".  Returned as a convenience for operations that want
+to use the new value after the variable has been updated.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, the subtraction will be protected by a lock;
+otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Update \'ref\' by subtracting \'value\' from it."
+  description: <<END
+This operation outputs "ref" after the update is done.
+This makes it easier to chain operations that need to use the reset value.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AssignSubVariableOp.pbtxt b/tensorflow/core/api_def/base_api/api_def_AssignSubVariableOp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..102201c4cb07b080c46a28a91af8a4176034f6e6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AssignSubVariableOp.pbtxt
@@ -0,0 +1,29 @@
+op {
+  graph_op_name: "AssignSubVariableOp"
+  in_arg {
+    name: "resource"
+    description: <<END
+handle to the resource in which to store the variable.
+END
+  }
+  in_arg {
+    name: "value"
+    description: <<END
+the value by which the variable will be incremented.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+the dtype of the value.
+END
+  }
+  summary: "Subtracts a value from the current value of a variable."
+  description: <<END
+Any ReadVariableOp which depends directly or indirectly on this assign is
+guaranteed to see the incremented value or a subsequent newer one.
+
+Outputs the incremented value, which can be used to totally order the
+increments to this variable.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AssignVariableOp.pbtxt b/tensorflow/core/api_def/base_api/api_def_AssignVariableOp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d6fe81d573120678b350b07c35b1da4960fcb36e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AssignVariableOp.pbtxt
@@ -0,0 +1,26 @@
+op {
+  graph_op_name: "AssignVariableOp"
+  in_arg {
+    name: "resource"
+    description: <<END
+handle to the resource in which to store the variable.
+END
+  }
+  in_arg {
+    name: "value"
+    description: <<END
+the value to set the new tensor to use.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+the dtype of the value.
+END
+  }
+  summary: "Assigns a new value to a variable."
+  description: <<END
+Any ReadVariableOp with a control dependency on this op is guaranteed to return
+this value or a subsequent newer value of the variable.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Atan.pbtxt b/tensorflow/core/api_def/base_api/api_def_Atan.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..557cf183e4f321afea6246c0348342281ecfdea9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Atan.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Atan"
+  summary: "Computes atan of x element-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Atan2.pbtxt b/tensorflow/core/api_def/base_api/api_def_Atan2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d2c8ef593932374b940898cb4c72f37e3a7ff14e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Atan2.pbtxt
@@ -0,0 +1,11 @@
+op {
+  graph_op_name: "Atan2"
+  summary: "Computes arctangent of `y/x` element-wise, respecting signs of the arguments."
+  description: <<END
+This is the angle \( \theta \in [-\pi, \pi] \) such that
+\[ x = r \cos(\theta) \]
+and
+\[ y = r \sin(\theta) \]
+where \(r = \sqrt(x^2 + y^2) \).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Atanh.pbtxt b/tensorflow/core/api_def/base_api/api_def_Atanh.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0ef1180f3d61f85adb853e17d98eb89ea21645f6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Atanh.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Atanh"
+  summary: "Computes inverse hyperbolic tangent of x element-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AudioSpectrogram.pbtxt b/tensorflow/core/api_def/base_api/api_def_AudioSpectrogram.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6631f4e04cb4dc9a911d563a75433c52f4077dc3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AudioSpectrogram.pbtxt
@@ -0,0 +1,63 @@
+op {
+  graph_op_name: "AudioSpectrogram"
+  in_arg {
+    name: "input"
+    description: <<END
+Float representation of audio data.
+END
+  }
+  out_arg {
+    name: "spectrogram"
+    description: <<END
+3D representation of the audio frequencies as an image.
+END
+  }
+  attr {
+    name: "window_size"
+    description: <<END
+How wide the input window is in samples. For the highest efficiency
+this should be a power of two, but other values are accepted.
+END
+  }
+  attr {
+    name: "stride"
+    description: <<END
+How widely apart the center of adjacent sample windows should be.
+END
+  }
+  attr {
+    name: "magnitude_squared"
+    description: <<END
+Whether to return the squared magnitude or just the
+magnitude. Using squared magnitude can avoid extra calculations.
+END
+  }
+  summary: "Produces a visualization of audio data over time."
+  description: <<END
+Spectrograms are a standard way of representing audio information as a series of
+slices of frequency information, one slice for each window of time. By joining
+these together into a sequence, they form a distinctive fingerprint of the sound
+over time.
+
+This op expects to receive audio data as an input, stored as floats in the range
+-1 to 1, together with a window width in samples, and a stride specifying how
+far to move the window between slices. From this it generates a three
+dimensional output. The lowest dimension has an amplitude value for each
+frequency during that time slice. The next dimension is time, with successive
+frequency slices. The final dimension is for the channels in the input, so a
+stereo audio input would have two here for example.
+
+This means the layout when converted and saved as an image is rotated 90 degrees
+clockwise from a typical spectrogram. Time is descending down the Y axis, and
+the frequency decreases from left to right.
+
+Each value in the result represents the square root of the sum of the real and
+imaginary parts of an FFT on the current window of samples. In this way, the
+lowest dimension represents the power of each frequency in the current window,
+and adjacent windows are concatenated in the next dimension.
+
+To get a more intuitive and visual look at what this operation does, you can run
+tensorflow/examples/wav_to_spectrogram to read in an audio file and save out the
+resulting spectrogram as a PNG image.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AudioSummary.pbtxt b/tensorflow/core/api_def/base_api/api_def_AudioSummary.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3bc70d7ce8afa94b48ed1313936371689caf397a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AudioSummary.pbtxt
@@ -0,0 +1,47 @@
+op {
+  graph_op_name: "AudioSummary"
+  in_arg {
+    name: "tag"
+    description: <<END
+Scalar. Used to build the `tag` attribute of the summary values.
+END
+  }
+  in_arg {
+    name: "tensor"
+    description: <<END
+2-D of shape `[batch_size, frames]`.
+END
+  }
+  out_arg {
+    name: "summary"
+    description: <<END
+Scalar. Serialized `Summary` protocol buffer.
+END
+  }
+  attr {
+    name: "sample_rate"
+    description: <<END
+The sample rate of the signal in hertz.
+END
+  }
+  attr {
+    name: "max_outputs"
+    description: <<END
+Max number of batch elements to generate audio for.
+END
+  }
+  summary: "Outputs a `Summary` protocol buffer with audio."
+  description: <<END
+The summary has up to `max_outputs` summary values containing audio. The
+audio is built from `tensor` which must be 3-D with shape `[batch_size,
+frames, channels]` or 2-D with shape `[batch_size, frames]`. The values are
+assumed to be in the range of `[-1.0, 1.0]` with a sample rate of `sample_rate`.
+
+The `tag` argument is a scalar `Tensor` of type `string`.  It is used to
+build the `tag` of the summary values:
+
+*  If `max_outputs` is 1, the summary value tag is '*tag*/audio'.
+*  If `max_outputs` is greater than 1, the summary value tags are
+   generated sequentially as '*tag*/audio/0', '*tag*/audio/1', etc.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AudioSummaryV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_AudioSummaryV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d406f22d3511f9d80a56b7296dfe5e9727aef2cb
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AudioSummaryV2.pbtxt
@@ -0,0 +1,50 @@
+op {
+  graph_op_name: "AudioSummaryV2"
+  endpoint {
+    name: "AudioSummary"
+  }
+  in_arg {
+    name: "tag"
+    description: <<END
+Scalar. Used to build the `tag` attribute of the summary values.
+END
+  }
+  in_arg {
+    name: "tensor"
+    description: <<END
+2-D of shape `[batch_size, frames]`.
+END
+  }
+  in_arg {
+    name: "sample_rate"
+    description: <<END
+The sample rate of the signal in hertz.
+END
+  }
+  out_arg {
+    name: "summary"
+    description: <<END
+Scalar. Serialized `Summary` protocol buffer.
+END
+  }
+  attr {
+    name: "max_outputs"
+    description: <<END
+Max number of batch elements to generate audio for.
+END
+  }
+  summary: "Outputs a `Summary` protocol buffer with audio."
+  description: <<END
+The summary has up to `max_outputs` summary values containing audio. The
+audio is built from `tensor` which must be 3-D with shape `[batch_size,
+frames, channels]` or 2-D with shape `[batch_size, frames]`. The values are
+assumed to be in the range of `[-1.0, 1.0]` with a sample rate of `sample_rate`.
+
+The `tag` argument is a scalar `Tensor` of type `string`.  It is used to
+build the `tag` of the summary values:
+
+*  If `max_outputs` is 1, the summary value tag is '*tag*/audio'.
+*  If `max_outputs` is greater than 1, the summary value tags are
+   generated sequentially as '*tag*/audio/0', '*tag*/audio/1', etc.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AvgPool.pbtxt b/tensorflow/core/api_def/base_api/api_def_AvgPool.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1d94662f6a22175cafe76de19d9502fad95d9644
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AvgPool.pbtxt
@@ -0,0 +1,48 @@
+op {
+  graph_op_name: "AvgPool"
+  in_arg {
+    name: "value"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The average pooled output tensor.
+END
+  }
+  attr {
+    name: "ksize"
+    description: <<END
+The size of the sliding window for each dimension of `value`.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of `value`.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+Specify the data format of the input and output data. With the
+default format "NHWC", the data is stored in the order of:
+    [batch, in_height, in_width, in_channels].
+Alternatively, the format could be "NCHW", the data storage order of:
+    [batch, in_channels, in_height, in_width].
+END
+  }
+  summary: "Performs average pooling on the input."
+  description: <<END
+Each entry in `output` is the mean of the corresponding size `ksize`
+window in `value`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AvgPool3D.pbtxt b/tensorflow/core/api_def/base_api/api_def_AvgPool3D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8171566a212b73ac15dbc116d2ea44eb6cb4fb92
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AvgPool3D.pbtxt
@@ -0,0 +1,46 @@
+op {
+  graph_op_name: "AvgPool3D"
+  in_arg {
+    name: "input"
+    description: <<END
+Shape `[batch, depth, rows, cols, channels]` tensor to pool over.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The average pooled output tensor.
+END
+  }
+  attr {
+    name: "ksize"
+    description: <<END
+1-D tensor of length 5. The size of the window for each dimension of
+the input tensor. Must have `ksize[0] = ksize[4] = 1`.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+1-D tensor of length 5. The stride of the sliding window for each
+dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+The data format of the input and output data. With the
+default format "NDHWC", the data is stored in the order of:
+    [batch, in_depth, in_height, in_width, in_channels].
+Alternatively, the format could be "NCDHW", the data storage order is:
+    [batch, in_channels, in_depth, in_height, in_width].
+END
+  }
+  summary: "Performs 3D average pooling on the input."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AvgPool3DGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_AvgPool3DGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6f96be48739a1a207a2ff0bd05aadd88278b2591
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AvgPool3DGrad.pbtxt
@@ -0,0 +1,52 @@
+op {
+  graph_op_name: "AvgPool3DGrad"
+  in_arg {
+    name: "orig_input_shape"
+    description: <<END
+The original input dimensions.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+Output backprop of shape `[batch, depth, rows, cols, channels]`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The backprop for input.
+END
+  }
+  attr {
+    name: "ksize"
+    description: <<END
+1-D tensor of length 5. The size of the window for each dimension of
+the input tensor. Must have `ksize[0] = ksize[4] = 1`.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+1-D tensor of length 5. The stride of the sliding window for each
+dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+The data format of the input and output data. With the
+default format "NDHWC", the data is stored in the order of:
+    [batch, in_depth, in_height, in_width, in_channels].
+Alternatively, the format could be "NCDHW", the data storage order is:
+    [batch, in_channels, in_depth, in_height, in_width].
+END
+  }
+  summary: "Computes gradients of average pooling function."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_AvgPoolGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_AvgPoolGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..84e77f3ced7fdcb0bc6c0537cfed2210a460e443
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_AvgPoolGrad.pbtxt
@@ -0,0 +1,52 @@
+op {
+  graph_op_name: "AvgPoolGrad"
+  visibility: HIDDEN
+  in_arg {
+    name: "orig_input_shape"
+    description: <<END
+1-D.  Shape of the original input to `avg_pool`.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.  Gradients w.r.t.
+the output of `avg_pool`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+4-D.  Gradients w.r.t. the input of `avg_pool`.
+END
+  }
+  attr {
+    name: "ksize"
+    description: <<END
+The size of the sliding window for each dimension of the input.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the input.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+Specify the data format of the input and output data. With the
+default format "NHWC", the data is stored in the order of:
+    [batch, in_height, in_width, in_channels].
+Alternatively, the format could be "NCHW", the data storage order of:
+    [batch, in_channels, in_height, in_width].
+END
+  }
+  summary: "Computes gradients of the average pooling function."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_B.pbtxt b/tensorflow/core/api_def/base_api/api_def_B.pbtxt
deleted file mode 100644
index 716d397f9a3d4bca268d625116890430d0c294f8..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_B.pbtxt
+++ /dev/null
@@ -1,448 +0,0 @@
-op {
-  graph_op_name: "Barrier"
-  endpoint {
-    name: "Barrier"
-  }
-  summary: "Defines a barrier that persists across different graph executions."
-  description: <<END
-A barrier represents a key-value map, where each key is a string, and
-each value is a tuple of tensors.
-
-At runtime, the barrier contains 'complete' and 'incomplete'
-elements. A complete element has defined tensors for all components of
-its value tuple, and may be accessed using BarrierTakeMany. An
-incomplete element has some undefined components in its value tuple,
-and may be updated using BarrierInsertMany.
-END
-}
-op {
-  graph_op_name: "BarrierClose"
-  endpoint {
-    name: "BarrierClose"
-  }
-  summary: "Closes the given barrier."
-  description: <<END
-This operation signals that no more new elements will be inserted in the
-given barrier. Subsequent InsertMany that try to introduce a new key will fail.
-Subsequent InsertMany operations that just add missing components to already
-existing elements will continue to succeed. Subsequent TakeMany operations will
-continue to succeed if sufficient completed elements remain in the barrier.
-Subsequent TakeMany operations that would block will fail immediately.
-END
-}
-op {
-  graph_op_name: "BarrierIncompleteSize"
-  endpoint {
-    name: "BarrierIncompleteSize"
-  }
-  summary: "Computes the number of incomplete elements in the given barrier."
-}
-op {
-  graph_op_name: "BarrierInsertMany"
-  endpoint {
-    name: "BarrierInsertMany"
-  }
-  summary: "For each key, assigns the respective value to the specified component."
-  description: <<END
-If a key is not found in the barrier, this operation will create a new
-incomplete element. If a key is found in the barrier, and the element
-already has a value at component_index, this operation will fail with
-INVALID_ARGUMENT, and leave the barrier in an undefined state.
-END
-}
-op {
-  graph_op_name: "BarrierReadySize"
-  endpoint {
-    name: "BarrierReadySize"
-  }
-  summary: "Computes the number of complete elements in the given barrier."
-}
-op {
-  graph_op_name: "BarrierTakeMany"
-  endpoint {
-    name: "BarrierTakeMany"
-  }
-  summary: "Takes the given number of completed elements from a barrier."
-  description: <<END
-This operation concatenates completed-element component tensors along
-the 0th dimension to make a single component tensor.
-
-Elements come out of the barrier when they are complete, and in the order
-in which they were placed into the barrier.  The indices output provides
-information about the batch in which each element was originally inserted
-into the barrier.
-END
-}
-op {
-  graph_op_name: "BatchCholesky"
-  endpoint {
-    name: "BatchCholesky"
-  }
-}
-op {
-  graph_op_name: "BatchCholeskyGrad"
-  endpoint {
-    name: "BatchCholeskyGrad"
-  }
-}
-op {
-  graph_op_name: "BatchDataset"
-  endpoint {
-    name: "BatchDataset"
-  }
-  summary: "Creates a dataset that batches `batch_size` elements from `input_dataset`."
-}
-op {
-  graph_op_name: "BatchFFT"
-  endpoint {
-    name: "BatchFFT"
-  }
-}
-op {
-  graph_op_name: "BatchFFT2D"
-  endpoint {
-    name: "BatchFFT2D"
-  }
-}
-op {
-  graph_op_name: "BatchFFT3D"
-  endpoint {
-    name: "BatchFFT3D"
-  }
-}
-op {
-  graph_op_name: "BatchIFFT"
-  endpoint {
-    name: "BatchIFFT"
-  }
-}
-op {
-  graph_op_name: "BatchIFFT2D"
-  endpoint {
-    name: "BatchIFFT2D"
-  }
-}
-op {
-  graph_op_name: "BatchIFFT3D"
-  endpoint {
-    name: "BatchIFFT3D"
-  }
-}
-op {
-  graph_op_name: "BatchMatMul"
-  endpoint {
-    name: "BatchMatMul"
-  }
-  summary: "Multiplies slices of two tensors in batches."
-  description: <<END
-Multiplies all slices of `Tensor` `x` and `y` (each slice can be
-viewed as an element of a batch), and arranges the individual results
-in a single output tensor of the same batch size. Each of the
-individual slices can optionally be adjointed (to adjoint a matrix
-means to transpose and conjugate it) before multiplication by setting
-the `adj_x` or `adj_y` flag to `True`, which are by default `False`.
-
-The input tensors `x` and `y` are 2-D or higher with shape `[..., r_x, c_x]`
-and `[..., r_y, c_y]`.
-
-The output tensor is 2-D or higher with shape `[..., r_o, c_o]`, where:
-
-    r_o = c_x if adj_x else r_x
-    c_o = r_y if adj_y else c_y
-
-It is computed as:
-
-    output[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :])
-END
-}
-op {
-  graph_op_name: "BatchMatrixBandPart"
-  endpoint {
-    name: "BatchMatrixBandPart"
-  }
-}
-op {
-  graph_op_name: "BatchMatrixDeterminant"
-  endpoint {
-    name: "BatchMatrixDeterminant"
-  }
-}
-op {
-  graph_op_name: "BatchMatrixDiag"
-  endpoint {
-    name: "BatchMatrixDiag"
-  }
-}
-op {
-  graph_op_name: "BatchMatrixDiagPart"
-  endpoint {
-    name: "BatchMatrixDiagPart"
-  }
-}
-op {
-  graph_op_name: "BatchMatrixInverse"
-  endpoint {
-    name: "BatchMatrixInverse"
-  }
-}
-op {
-  graph_op_name: "BatchMatrixSetDiag"
-  endpoint {
-    name: "BatchMatrixSetDiag"
-  }
-}
-op {
-  graph_op_name: "BatchMatrixSolve"
-  endpoint {
-    name: "BatchMatrixSolve"
-  }
-}
-op {
-  graph_op_name: "BatchMatrixSolveLs"
-  endpoint {
-    name: "BatchMatrixSolveLs"
-  }
-}
-op {
-  graph_op_name: "BatchMatrixTriangularSolve"
-  endpoint {
-    name: "BatchMatrixTriangularSolve"
-  }
-}
-op {
-  graph_op_name: "BatchNormWithGlobalNormalization"
-  endpoint {
-    name: "BatchNormWithGlobalNormalization"
-  }
-  summary: "Batch normalization."
-  description: <<END
-This op is deprecated. Prefer `tf.nn.batch_normalization`.
-END
-}
-op {
-  graph_op_name: "BatchNormWithGlobalNormalizationGrad"
-  endpoint {
-    name: "BatchNormWithGlobalNormalizationGrad"
-  }
-  summary: "Gradients for batch normalization."
-  description: <<END
-This op is deprecated. See `tf.nn.batch_normalization`.
-END
-}
-op {
-  graph_op_name: "BatchSelfAdjointEig"
-  endpoint {
-    name: "BatchSelfAdjointEig"
-  }
-}
-op {
-  graph_op_name: "BatchSelfAdjointEigV2"
-  endpoint {
-    name: "BatchSelfAdjointEigV2"
-  }
-}
-op {
-  graph_op_name: "BatchSvd"
-  endpoint {
-    name: "BatchSvd"
-  }
-}
-op {
-  graph_op_name: "BatchToSpace"
-  endpoint {
-    name: "BatchToSpace"
-  }
-  summary: "BatchToSpace for 4-D tensors of type T."
-  description: <<END
-This is a legacy version of the more general BatchToSpaceND.
-
-Rearranges (permutes) data from batch into blocks of spatial data, followed by
-cropping. This is the reverse transformation of SpaceToBatch. More specifically,
-this op outputs a copy of the input tensor where values from the `batch`
-dimension are moved in spatial blocks to the `height` and `width` dimensions,
-followed by cropping along the `height` and `width` dimensions.
-END
-}
-op {
-  graph_op_name: "BatchToSpaceND"
-  endpoint {
-    name: "BatchToSpaceND"
-  }
-  summary: "BatchToSpace for N-D tensors of type T."
-  description: <<END
-This operation reshapes the "batch" dimension 0 into `M + 1` dimensions of shape
-`block_shape + [batch]`, interleaves these blocks back into the grid defined by
-the spatial dimensions `[1, ..., M]`, to obtain a result with the same rank as
-the input.  The spatial dimensions of this intermediate result are then
-optionally cropped according to `crops` to produce the output.  This is the
-reverse of SpaceToBatch.  See below for a precise description.
-END
-}
-op {
-  graph_op_name: "Betainc"
-  endpoint {
-    name: "Betainc"
-  }
-  summary: "Compute the regularized incomplete beta integral \\\\(I_x(a, b)\\\\)."
-  description: <<END
-The regularized incomplete beta integral is defined as:
-
-
-\\(I_x(a, b) = \frac{B(x; a, b)}{B(a, b)}\\)
-
-where
-
-
-\\(B(x; a, b) = \int_0^x t^{a-1} (1 - t)^{b-1} dt\\)
-
-
-is the incomplete beta function and \\(B(a, b)\\) is the *complete*
-beta function.
-END
-}
-op {
-  graph_op_name: "BiasAdd"
-  endpoint {
-    name: "BiasAdd"
-  }
-  summary: "Adds `bias` to `value`."
-  description: <<END
-This is a special case of `tf.add` where `bias` is restricted to be 1-D.
-Broadcasting is supported, so `value` may have any number of dimensions.
-END
-}
-op {
-  graph_op_name: "BiasAddGrad"
-  endpoint {
-    name: "BiasAddGrad"
-  }
-  summary: "The backward operation for \"BiasAdd\" on the \"bias\" tensor."
-  description: <<END
-It accumulates all the values from out_backprop into the feature dimension.
-For NHWC data format, the feature dimension is the last. For NCHW data format,
-the feature dimension is the third-to-last.
-END
-}
-op {
-  graph_op_name: "BiasAddV1"
-  endpoint {
-    name: "BiasAddV1"
-  }
-  summary: "Adds `bias` to `value`."
-  description: <<END
-This is a deprecated version of BiasAdd and will be soon removed.
-
-This is a special case of `tf.add` where `bias` is restricted to be 1-D.
-Broadcasting is supported, so `value` may have any number of dimensions.
-END
-}
-op {
-  graph_op_name: "Bincount"
-  endpoint {
-    name: "Bincount"
-  }
-  summary: "Counts the number of occurrences of each value in an integer array."
-  description: <<END
-Outputs a vector with length `size` and the same dtype as `weights`. If
-`weights` are empty, then index `i` stores the number of times the value `i` is
-counted in `arr`. If `weights` are non-empty, then index `i` stores the sum of
-the value in `weights` at each index where the corresponding value in `arr` is
-`i`.
-
-Values in `arr` outside of the range [0, size) are ignored.
-END
-}
-op {
-  graph_op_name: "Bitcast"
-  endpoint {
-    name: "Bitcast"
-  }
-  summary: "Bitcasts a tensor from one type to another without copying data."
-  description: <<END
-Given a tensor `input`, this operation returns a tensor that has the same buffer
-data as `input` with datatype `type`.
-
-If the input datatype `T` is larger than the output datatype `type` then the
-shape changes from [...] to [..., sizeof(`T`)/sizeof(`type`)].
-
-If `T` is smaller than `type`, the operator requires that the rightmost
-dimension be equal to sizeof(`type`)/sizeof(`T`). The shape then goes from
-[..., sizeof(`type`)/sizeof(`T`)] to [...].
-
-*NOTE*: Bitcast is implemented as a low-level cast, so machines with different
-endian orderings will give different results.
-END
-}
-op {
-  graph_op_name: "BitwiseAnd"
-  endpoint {
-    name: "BitwiseAnd"
-  }
-  summary: "Elementwise computes the bitwise AND of `x` and `y`."
-  description: <<END
-The result will have those bits set, that are set in both `x` and `y`. The
-computation is performed on the underlying representations of `x` and `y`.
-END
-}
-op {
-  graph_op_name: "BitwiseOr"
-  endpoint {
-    name: "BitwiseOr"
-  }
-  summary: "Elementwise computes the bitwise OR of `x` and `y`."
-  description: <<END
-The result will have those bits set, that are set in `x`, `y` or both. The
-computation is performed on the underlying representations of `x` and `y`.
-END
-}
-op {
-  graph_op_name: "BitwiseXor"
-  endpoint {
-    name: "BitwiseXor"
-  }
-  summary: "Elementwise computes the bitwise XOR of `x` and `y`."
-  description: <<END
-The result will have those bits set, that are different in `x` and `y`. The
-computation is performed on the underlying representations of `x` and `y`.
-END
-}
-op {
-  graph_op_name: "BroadcastArgs"
-  endpoint {
-    name: "BroadcastArgs"
-  }
-  summary: "Return the shape of s0 op s1 with broadcast."
-  description: <<END
-Given `s0` and `s1`, tensors that represent shapes, compute `r0`, the
-broadcasted shape. `s0`, `s1` and `r0` are all integer vectors.
-END
-}
-op {
-  graph_op_name: "BroadcastGradientArgs"
-  endpoint {
-    name: "BroadcastGradientArgs"
-  }
-  summary: "Return the reduction indices for computing gradients of s0 op s1 with broadcast."
-  description: <<END
-This is typically used by gradient computations for a broadcasting operation.
-END
-}
-op {
-  graph_op_name: "Bucketize"
-  endpoint {
-    name: "Bucketize"
-  }
-  summary: "Bucketizes \'input\' based on \'boundaries\'."
-  description: <<END
-For example, if the inputs are
-    boundaries = [0, 10, 100]
-    input = [[-5, 10000]
-             [150,   10]
-             [5,    100]]
-
-then the output will be
-    output = [[0, 3]
-              [3, 2]
-              [1, 3]]
-END
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_Barrier.pbtxt b/tensorflow/core/api_def/base_api/api_def_Barrier.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3422ebf2f6d607addd90b4bb9705fa44656ae79c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Barrier.pbtxt
@@ -0,0 +1,55 @@
+op {
+  graph_op_name: "Barrier"
+  out_arg {
+    name: "handle"
+    description: <<END
+The handle to the barrier.
+END
+  }
+  attr {
+    name: "component_types"
+    description: <<END
+The type of each component in a value.
+END
+  }
+  attr {
+    name: "shapes"
+    description: <<END
+The shape of each component in a value. Each shape must be 1 in the
+first dimension. The length of this attr must be the same as the length of
+component_types.
+END
+  }
+  attr {
+    name: "capacity"
+    description: <<END
+The capacity of the barrier.  The default capacity is MAX_INT32,
+which is the largest capacity of the underlying queue.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this barrier is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this barrier will be shared under the given name
+across multiple sessions.
+END
+  }
+  summary: "Defines a barrier that persists across different graph executions."
+  description: <<END
+A barrier represents a key-value map, where each key is a string, and
+each value is a tuple of tensors.
+
+At runtime, the barrier contains 'complete' and 'incomplete'
+elements. A complete element has defined tensors for all components of
+its value tuple, and may be accessed using BarrierTakeMany. An
+incomplete element has some undefined components in its value tuple,
+and may be updated using BarrierInsertMany.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BarrierClose.pbtxt b/tensorflow/core/api_def/base_api/api_def_BarrierClose.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a81235ce8a71d9c7613901ec8b71c7e380b74894
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BarrierClose.pbtxt
@@ -0,0 +1,26 @@
+op {
+  graph_op_name: "BarrierClose"
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a barrier.
+END
+  }
+  attr {
+    name: "cancel_pending_enqueues"
+    description: <<END
+If true, all pending enqueue requests that are
+blocked on the barrier's queue will be canceled. InsertMany will fail, even
+if no new key is introduced.
+END
+  }
+  summary: "Closes the given barrier."
+  description: <<END
+This operation signals that no more new elements will be inserted in the
+given barrier. Subsequent InsertMany that try to introduce a new key will fail.
+Subsequent InsertMany operations that just add missing components to already
+existing elements will continue to succeed. Subsequent TakeMany operations will
+continue to succeed if sufficient completed elements remain in the barrier.
+Subsequent TakeMany operations that would block will fail immediately.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BarrierIncompleteSize.pbtxt b/tensorflow/core/api_def/base_api/api_def_BarrierIncompleteSize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..61f41da77ffec7489987f1d4de1169800bb5117d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BarrierIncompleteSize.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "BarrierIncompleteSize"
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a barrier.
+END
+  }
+  out_arg {
+    name: "size"
+    description: <<END
+The number of incomplete elements (i.e. those with some of their value
+components not set) in the barrier.
+END
+  }
+  summary: "Computes the number of incomplete elements in the given barrier."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BarrierInsertMany.pbtxt b/tensorflow/core/api_def/base_api/api_def_BarrierInsertMany.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..645e1eee083ab15f7ee73a2576729d3fa2fcadfe
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BarrierInsertMany.pbtxt
@@ -0,0 +1,35 @@
+op {
+  graph_op_name: "BarrierInsertMany"
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a barrier.
+END
+  }
+  in_arg {
+    name: "keys"
+    description: <<END
+A one-dimensional tensor of keys, with length n.
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+An any-dimensional tensor of values, which are associated with the
+respective keys. The 0th dimension must have length n.
+END
+  }
+  attr {
+    name: "component_index"
+    description: <<END
+The component of the barrier elements that is being assigned.
+END
+  }
+  summary: "For each key, assigns the respective value to the specified component."
+  description: <<END
+If a key is not found in the barrier, this operation will create a new
+incomplete element. If a key is found in the barrier, and the element
+already has a value at component_index, this operation will fail with
+INVALID_ARGUMENT, and leave the barrier in an undefined state.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BarrierReadySize.pbtxt b/tensorflow/core/api_def/base_api/api_def_BarrierReadySize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..38e92d348302ec6c7cfb92eeb4713b7136667f2a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BarrierReadySize.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "BarrierReadySize"
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a barrier.
+END
+  }
+  out_arg {
+    name: "size"
+    description: <<END
+The number of complete elements (i.e. those with all of their value
+components set) in the barrier.
+END
+  }
+  summary: "Computes the number of complete elements in the given barrier."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BarrierTakeMany.pbtxt b/tensorflow/core/api_def/base_api/api_def_BarrierTakeMany.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..584ce7536b8af67c09949a72ef97f4cb93b6d143
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BarrierTakeMany.pbtxt
@@ -0,0 +1,68 @@
+op {
+  graph_op_name: "BarrierTakeMany"
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a barrier.
+END
+  }
+  in_arg {
+    name: "num_elements"
+    description: <<END
+A single-element tensor containing the number of elements to
+take.
+END
+  }
+  out_arg {
+    name: "indices"
+    description: <<END
+A one-dimensional tensor of indices, with length num_elems.
+These indices refer to the batch in which the values were placed into the
+barrier (starting with MIN_LONG and increasing with each BarrierInsertMany).
+END
+  }
+  out_arg {
+    name: "keys"
+    description: <<END
+A one-dimensional tensor of keys, with length num_elements.
+END
+  }
+  out_arg {
+    name: "values"
+    description: <<END
+One any-dimensional tensor per component in a barrier element. All
+values have length num_elements in the 0th dimension.
+END
+  }
+  attr {
+    name: "component_types"
+    description: <<END
+The type of each component in a value.
+END
+  }
+  attr {
+    name: "allow_small_batch"
+    description: <<END
+Allow to return less than num_elements items if barrier is
+already closed.
+END
+  }
+  attr {
+    name: "timeout_ms"
+    description: <<END
+If the queue is empty, this operation will block for up to
+timeout_ms milliseconds.
+Note: This option is not supported yet.
+END
+  }
+  summary: "Takes the given number of completed elements from a barrier."
+  description: <<END
+This operation concatenates completed-element component tensors along
+the 0th dimension to make a single component tensor.
+
+Elements come out of the barrier when they are complete, and in the order
+in which they were placed into the barrier.  The indices output provides
+information about the batch in which each element was originally inserted
+into the barrier.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchCholesky.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchCholesky.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..758ed3c6d398158952aa751efb60ce4976b97c0f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchCholesky.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchCholesky"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchCholeskyGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchCholeskyGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9099433f0bedfe551ae6587c67f21659713b4211
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchCholeskyGrad.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchCholeskyGrad"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..639d962874d083472e6df13550e107026fd2d0a1
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchDataset.pbtxt
@@ -0,0 +1,11 @@
+op {
+  graph_op_name: "BatchDataset"
+  in_arg {
+    name: "batch_size"
+    description: <<END
+A scalar representing the number of elements to accumulate in a
+batch.
+END
+  }
+  summary: "Creates a dataset that batches `batch_size` elements from `input_dataset`."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchFFT.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchFFT.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5ef542cc8b1367715361eec98fe727d9fa9f1a0f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchFFT.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchFFT"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchFFT2D.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchFFT2D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1ce0612aaf2063ae07f9070160b7ec4a1518e20e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchFFT2D.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchFFT2D"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchFFT3D.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchFFT3D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5834e0337fa3faa7a1de89547cae8570bcfabe73
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchFFT3D.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchFFT3D"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchIFFT.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchIFFT.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..931365f0a485ddb34a03c1c8497f7fc308daf920
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchIFFT.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchIFFT"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchIFFT2D.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchIFFT2D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..af0bf6246164281026900525f04aa5c60bbad8b8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchIFFT2D.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchIFFT2D"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchIFFT3D.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchIFFT3D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f051e1f5e0a7101e7c3ea518a58f0cdb93030436
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchIFFT3D.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchIFFT3D"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchMatMul.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchMatMul.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7999598aff2155b2b4620ce79120d60fad7aa63b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchMatMul.pbtxt
@@ -0,0 +1,54 @@
+op {
+  graph_op_name: "BatchMatMul"
+  in_arg {
+    name: "x"
+    description: <<END
+2-D or higher with shape `[..., r_x, c_x]`.
+END
+  }
+  in_arg {
+    name: "y"
+    description: <<END
+2-D or higher with shape `[..., r_y, c_y]`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+3-D or higher with shape `[..., r_o, c_o]`
+END
+  }
+  attr {
+    name: "adj_x"
+    description: <<END
+If `True`, adjoint the slices of `x`. Defaults to `False`.
+END
+  }
+  attr {
+    name: "adj_y"
+    description: <<END
+If `True`, adjoint the slices of `y`. Defaults to `False`.
+END
+  }
+  summary: "Multiplies slices of two tensors in batches."
+  description: <<END
+Multiplies all slices of `Tensor` `x` and `y` (each slice can be
+viewed as an element of a batch), and arranges the individual results
+in a single output tensor of the same batch size. Each of the
+individual slices can optionally be adjointed (to adjoint a matrix
+means to transpose and conjugate it) before multiplication by setting
+the `adj_x` or `adj_y` flag to `True`, which are by default `False`.
+
+The input tensors `x` and `y` are 2-D or higher with shape `[..., r_x, c_x]`
+and `[..., r_y, c_y]`.
+
+The output tensor is 2-D or higher with shape `[..., r_o, c_o]`, where:
+
+    r_o = c_x if adj_x else r_x
+    c_o = r_y if adj_y else c_y
+
+It is computed as:
+
+    output[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :])
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchMatrixBandPart.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchMatrixBandPart.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..592a95a14e80ec247b0842d8793ac54d164d7fe9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchMatrixBandPart.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchMatrixBandPart"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchMatrixDeterminant.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchMatrixDeterminant.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9f1c5a897ca005f2edd658b24394048294a1fd7d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchMatrixDeterminant.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchMatrixDeterminant"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchMatrixDiag.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchMatrixDiag.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f7ed5cca2b3f50319b4b70d10ed960fcbcbbb79b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchMatrixDiag.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchMatrixDiag"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchMatrixDiagPart.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchMatrixDiagPart.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e96bb9c57f772dbf26f18d0f85f2e1a2f2b9e74d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchMatrixDiagPart.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchMatrixDiagPart"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchMatrixInverse.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchMatrixInverse.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..41d4305f5f4a2e638f042ca56e18d99b76a24c19
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchMatrixInverse.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchMatrixInverse"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchMatrixSetDiag.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchMatrixSetDiag.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b11edf2ba10658619e466c9bf2ba9a4f677c277e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchMatrixSetDiag.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchMatrixSetDiag"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchMatrixSolve.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchMatrixSolve.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6012ea4a224eee8af98306ddf80bb99b82a1034c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchMatrixSolve.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchMatrixSolve"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchMatrixSolveLs.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchMatrixSolveLs.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0fd6e055c4ec41d31556891fdef38b583adefb12
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchMatrixSolveLs.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchMatrixSolveLs"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchMatrixTriangularSolve.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchMatrixTriangularSolve.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..22fcb4a02fe86007be02a5ef79093ef3e60d599f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchMatrixTriangularSolve.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchMatrixTriangularSolve"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchNormWithGlobalNormalization.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchNormWithGlobalNormalization.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2943f5f009f9268d13b9542ec4e4ba9cd5275a64
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchNormWithGlobalNormalization.pbtxt
@@ -0,0 +1,57 @@
+op {
+  graph_op_name: "BatchNormWithGlobalNormalization"
+  in_arg {
+    name: "t"
+    description: <<END
+A 4D input Tensor.
+END
+  }
+  in_arg {
+    name: "m"
+    description: <<END
+A 1D mean Tensor with size matching the last dimension of t.
+This is the first output from tf.nn.moments,
+or a saved moving average thereof.
+END
+  }
+  in_arg {
+    name: "v"
+    description: <<END
+A 1D variance Tensor with size matching the last dimension of t.
+This is the second output from tf.nn.moments,
+or a saved moving average thereof.
+END
+  }
+  in_arg {
+    name: "beta"
+    description: <<END
+A 1D beta Tensor with size matching the last dimension of t.
+An offset to be added to the normalized tensor.
+END
+  }
+  in_arg {
+    name: "gamma"
+    description: <<END
+A 1D gamma Tensor with size matching the last dimension of t.
+If "scale_after_normalization" is true, this tensor will be multiplied
+with the normalized tensor.
+END
+  }
+  attr {
+    name: "variance_epsilon"
+    description: <<END
+A small float number to avoid dividing by 0.
+END
+  }
+  attr {
+    name: "scale_after_normalization"
+    description: <<END
+A bool indicating whether the resulted tensor
+needs to be multiplied with gamma.
+END
+  }
+  summary: "Batch normalization."
+  description: <<END
+This op is deprecated. Prefer `tf.nn.batch_normalization`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchNormWithGlobalNormalizationGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchNormWithGlobalNormalizationGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a702e303f3d71c55a4eb1ab708bb41969c643980
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchNormWithGlobalNormalizationGrad.pbtxt
@@ -0,0 +1,86 @@
+op {
+  graph_op_name: "BatchNormWithGlobalNormalizationGrad"
+  in_arg {
+    name: "t"
+    description: <<END
+A 4D input Tensor.
+END
+  }
+  in_arg {
+    name: "m"
+    description: <<END
+A 1D mean Tensor with size matching the last dimension of t.
+This is the first output from tf.nn.moments,
+or a saved moving average thereof.
+END
+  }
+  in_arg {
+    name: "v"
+    description: <<END
+A 1D variance Tensor with size matching the last dimension of t.
+This is the second output from tf.nn.moments,
+or a saved moving average thereof.
+END
+  }
+  in_arg {
+    name: "gamma"
+    description: <<END
+A 1D gamma Tensor with size matching the last dimension of t.
+If "scale_after_normalization" is true, this Tensor will be multiplied
+with the normalized Tensor.
+END
+  }
+  in_arg {
+    name: "backprop"
+    description: <<END
+4D backprop Tensor.
+END
+  }
+  out_arg {
+    name: "dx"
+    description: <<END
+4D backprop tensor for input.
+END
+  }
+  out_arg {
+    name: "dm"
+    description: <<END
+1D backprop tensor for mean.
+END
+  }
+  out_arg {
+    name: "dv"
+    description: <<END
+1D backprop tensor for variance.
+END
+  }
+  out_arg {
+    name: "db"
+    description: <<END
+1D backprop tensor for beta.
+END
+  }
+  out_arg {
+    name: "dg"
+    description: <<END
+1D backprop tensor for gamma.
+END
+  }
+  attr {
+    name: "variance_epsilon"
+    description: <<END
+A small float number to avoid dividing by 0.
+END
+  }
+  attr {
+    name: "scale_after_normalization"
+    description: <<END
+A bool indicating whether the resulted tensor
+needs to be multiplied with gamma.
+END
+  }
+  summary: "Gradients for batch normalization."
+  description: <<END
+This op is deprecated. See `tf.nn.batch_normalization`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchSelfAdjointEig.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchSelfAdjointEig.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8fd3ee3b6b456e5a1278edb81db80b60dc814154
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchSelfAdjointEig.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchSelfAdjointEig"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchSelfAdjointEigV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchSelfAdjointEigV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9b025ab0486c29aff43c591ce9d99d43849b1c34
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchSelfAdjointEigV2.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchSelfAdjointEigV2"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchSvd.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchSvd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8e5a51b58fd1134141caa180a0a34151467877e8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchSvd.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "BatchSvd"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchToSpace.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchToSpace.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ee9a5a01a4b725478e92e65b243624e2b7c7f960
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchToSpace.pbtxt
@@ -0,0 +1,104 @@
+op {
+  graph_op_name: "BatchToSpace"
+  in_arg {
+    name: "input"
+    description: <<END
+4-D tensor with shape
+`[batch*block_size*block_size, height_pad/block_size, width_pad/block_size,
+  depth]`. Note that the batch size of the input tensor must be divisible by
+`block_size * block_size`.
+END
+  }
+  in_arg {
+    name: "crops"
+    description: <<END
+2-D tensor of non-negative integers with shape `[2, 2]`. It specifies
+how many elements to crop from the intermediate result across the spatial
+dimensions as follows:
+
+    crops = [[crop_top, crop_bottom], [crop_left, crop_right]]
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+4-D with shape `[batch, height, width, depth]`, where:
+
+      height = height_pad - crop_top - crop_bottom
+      width = width_pad - crop_left - crop_right
+
+The attr `block_size` must be greater than one. It indicates the block size.
+
+Some examples:
+
+(1) For the following input of shape `[4, 1, 1, 1]` and block_size of 2:
+
+```
+[[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
+```
+
+The output tensor has shape `[1, 2, 2, 1]` and value:
+
+```
+x = [[[[1], [2]], [[3], [4]]]]
+```
+
+(2) For the following input of shape `[4, 1, 1, 3]` and block_size of 2:
+
+```
+[[[1, 2, 3]], [[4, 5, 6]], [[7, 8, 9]], [[10, 11, 12]]]
+```
+
+The output tensor has shape `[1, 2, 2, 3]` and value:
+
+```
+x = [[[[1, 2, 3], [4, 5, 6]],
+      [[7, 8, 9], [10, 11, 12]]]]
+```
+
+(3) For the following input of shape `[4, 2, 2, 1]` and block_size of 2:
+
+```
+x = [[[[1], [3]], [[9], [11]]],
+     [[[2], [4]], [[10], [12]]],
+     [[[5], [7]], [[13], [15]]],
+     [[[6], [8]], [[14], [16]]]]
+```
+
+The output tensor has shape `[1, 4, 4, 1]` and value:
+
+```
+x = [[[1],   [2],  [3],  [4]],
+     [[5],   [6],  [7],  [8]],
+     [[9],  [10], [11],  [12]],
+     [[13], [14], [15],  [16]]]
+```
+
+(4) For the following input of shape `[8, 1, 2, 1]` and block_size of 2:
+
+```
+x = [[[[1], [3]]], [[[9], [11]]], [[[2], [4]]], [[[10], [12]]],
+     [[[5], [7]]], [[[13], [15]]], [[[6], [8]]], [[[14], [16]]]]
+```
+
+The output tensor has shape `[2, 2, 4, 1]` and value:
+
+```
+x = [[[[1], [3]], [[5], [7]]],
+     [[[2], [4]], [[10], [12]]],
+     [[[5], [7]], [[13], [15]]],
+     [[[6], [8]], [[14], [16]]]]
+```
+END
+  }
+  summary: "BatchToSpace for 4-D tensors of type T."
+  description: <<END
+This is a legacy version of the more general BatchToSpaceND.
+
+Rearranges (permutes) data from batch into blocks of spatial data, followed by
+cropping. This is the reverse transformation of SpaceToBatch. More specifically,
+this op outputs a copy of the input tensor where values from the `batch`
+dimension are moved in spatial blocks to the `height` and `width` dimensions,
+followed by cropping along the `height` and `width` dimensions.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BatchToSpaceND.pbtxt b/tensorflow/core/api_def/base_api/api_def_BatchToSpaceND.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8e25f9995e7c008ecc000e10213ece67d6f25172
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BatchToSpaceND.pbtxt
@@ -0,0 +1,139 @@
+op {
+  graph_op_name: "BatchToSpaceND"
+  in_arg {
+    name: "input"
+    description: <<END
+N-D with shape `input_shape = [batch] + spatial_shape + remaining_shape`,
+where spatial_shape has M dimensions.
+END
+  }
+  in_arg {
+    name: "block_shape"
+    description: <<END
+1-D with shape `[M]`, all values must be >= 1.
+END
+  }
+  in_arg {
+    name: "crops"
+    description: <<END
+2-D with shape `[M, 2]`, all values must be >= 0.
+  `crops[i] = [crop_start, crop_end]` specifies the amount to crop from input
+  dimension `i + 1`, which corresponds to spatial dimension `i`.  It is
+  required that
+  `crop_start[i] + crop_end[i] <= block_shape[i] * input_shape[i + 1]`.
+
+This operation is equivalent to the following steps:
+
+1. Reshape `input` to `reshaped` of shape:
+     [block_shape[0], ..., block_shape[M-1],
+      batch / prod(block_shape),
+      input_shape[1], ..., input_shape[N-1]]
+
+2. Permute dimensions of `reshaped` to produce `permuted` of shape
+     [batch / prod(block_shape),
+
+      input_shape[1], block_shape[0],
+      ...,
+      input_shape[M], block_shape[M-1],
+
+      input_shape[M+1], ..., input_shape[N-1]]
+
+3. Reshape `permuted` to produce `reshaped_permuted` of shape
+     [batch / prod(block_shape),
+
+      input_shape[1] * block_shape[0],
+      ...,
+      input_shape[M] * block_shape[M-1],
+
+      input_shape[M+1],
+      ...,
+      input_shape[N-1]]
+
+4. Crop the start and end of dimensions `[1, ..., M]` of
+   `reshaped_permuted` according to `crops` to produce the output of shape:
+     [batch / prod(block_shape),
+
+      input_shape[1] * block_shape[0] - crops[0,0] - crops[0,1],
+      ...,
+      input_shape[M] * block_shape[M-1] - crops[M-1,0] - crops[M-1,1],
+
+      input_shape[M+1], ..., input_shape[N-1]]
+
+Some examples:
+
+(1) For the following input of shape `[4, 1, 1, 1]`, `block_shape = [2, 2]`, and
+    `crops = [[0, 0], [0, 0]]`:
+
+```
+[[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
+```
+
+The output tensor has shape `[1, 2, 2, 1]` and value:
+
+```
+x = [[[[1], [2]], [[3], [4]]]]
+```
+
+(2) For the following input of shape `[4, 1, 1, 3]`, `block_shape = [2, 2]`, and
+    `crops = [[0, 0], [0, 0]]`:
+
+```
+[[[1, 2, 3]], [[4, 5, 6]], [[7, 8, 9]], [[10, 11, 12]]]
+```
+
+The output tensor has shape `[1, 2, 2, 3]` and value:
+
+```
+x = [[[[1, 2, 3], [4, 5, 6]],
+      [[7, 8, 9], [10, 11, 12]]]]
+```
+
+(3) For the following input of shape `[4, 2, 2, 1]`, `block_shape = [2, 2]`, and
+    `crops = [[0, 0], [0, 0]]`:
+
+```
+x = [[[[1], [3]], [[9], [11]]],
+     [[[2], [4]], [[10], [12]]],
+     [[[5], [7]], [[13], [15]]],
+     [[[6], [8]], [[14], [16]]]]
+```
+
+The output tensor has shape `[1, 4, 4, 1]` and value:
+
+```
+x = [[[1],   [2],  [3],  [4]],
+     [[5],   [6],  [7],  [8]],
+     [[9],  [10], [11],  [12]],
+     [[13], [14], [15],  [16]]]
+```
+
+(4) For the following input of shape `[8, 1, 3, 1]`, `block_shape = [2, 2]`, and
+    `crops = [[0, 0], [2, 0]]`:
+
+```
+x = [[[[0], [1], [3]]], [[[0], [9], [11]]],
+     [[[0], [2], [4]]], [[[0], [10], [12]]],
+     [[[0], [5], [7]]], [[[0], [13], [15]]],
+     [[[0], [6], [8]]], [[[0], [14], [16]]]]
+```
+
+The output tensor has shape `[2, 2, 4, 1]` and value:
+
+```
+x = [[[[1],   [2],  [3],  [4]],
+      [[5],   [6],  [7],  [8]]],
+     [[[9],  [10], [11],  [12]],
+      [[13], [14], [15],  [16]]]]
+```
+END
+  }
+  summary: "BatchToSpace for N-D tensors of type T."
+  description: <<END
+This operation reshapes the "batch" dimension 0 into `M + 1` dimensions of shape
+`block_shape + [batch]`, interleaves these blocks back into the grid defined by
+the spatial dimensions `[1, ..., M]`, to obtain a result with the same rank as
+the input.  The spatial dimensions of this intermediate result are then
+optionally cropped according to `crops` to produce the output.  This is the
+reverse of SpaceToBatch.  See below for a precise description.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Betainc.pbtxt b/tensorflow/core/api_def/base_api/api_def_Betainc.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5d7df75122c7893175d1efe39fd439dbe642e2c3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Betainc.pbtxt
@@ -0,0 +1,19 @@
+op {
+  graph_op_name: "Betainc"
+  summary: "Compute the regularized incomplete beta integral \\\\(I_x(a, b)\\\\)."
+  description: <<END
+The regularized incomplete beta integral is defined as:
+
+
+\\(I_x(a, b) = \frac{B(x; a, b)}{B(a, b)}\\)
+
+where
+
+
+\\(B(x; a, b) = \int_0^x t^{a-1} (1 - t)^{b-1} dt\\)
+
+
+is the incomplete beta function and \\(B(a, b)\\) is the *complete*
+beta function.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BiasAdd.pbtxt b/tensorflow/core/api_def/base_api/api_def_BiasAdd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..58266e74a2e335472d4fb4fe36d0d9e0c16649a4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BiasAdd.pbtxt
@@ -0,0 +1,38 @@
+op {
+  graph_op_name: "BiasAdd"
+  in_arg {
+    name: "value"
+    description: <<END
+Any number of dimensions.
+END
+  }
+  in_arg {
+    name: "bias"
+    description: <<END
+1-D with size the last dimension of `value`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Broadcasted sum of `value` and `bias`.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+Specify the data format of the input and output data. With the
+default format "NHWC", the bias tensor will be added to the last dimension
+of the value tensor.
+Alternatively, the format could be "NCHW", the data storage order of:
+    [batch, in_channels, in_height, in_width].
+The tensor will be added to "in_channels", the third-to-the-last
+    dimension.
+END
+  }
+  summary: "Adds `bias` to `value`."
+  description: <<END
+This is a special case of `tf.add` where `bias` is restricted to be 1-D.
+Broadcasting is supported, so `value` may have any number of dimensions.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BiasAddGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_BiasAddGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5f2adf1a35737271ea4fcd28707bf3cf7bf249a8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BiasAddGrad.pbtxt
@@ -0,0 +1,33 @@
+op {
+  graph_op_name: "BiasAddGrad"
+  in_arg {
+    name: "out_backprop"
+    description: <<END
+Any number of dimensions.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+1-D with size the feature dimension of `out_backprop`.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+Specify the data format of the input and output data. With the
+default format "NHWC", the bias tensor will be added to the last dimension
+of the value tensor.
+Alternatively, the format could be "NCHW", the data storage order of:
+    [batch, in_channels, in_height, in_width].
+The tensor will be added to "in_channels", the third-to-the-last
+    dimension.
+END
+  }
+  summary: "The backward operation for \"BiasAdd\" on the \"bias\" tensor."
+  description: <<END
+It accumulates all the values from out_backprop into the feature dimension.
+For NHWC data format, the feature dimension is the last. For NCHW data format,
+the feature dimension is the third-to-last.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BiasAddV1.pbtxt b/tensorflow/core/api_def/base_api/api_def_BiasAddV1.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9799682bf27b84baa525698c90abc5b69341e184
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BiasAddV1.pbtxt
@@ -0,0 +1,29 @@
+op {
+  graph_op_name: "BiasAddV1"
+  visibility: SKIP
+  in_arg {
+    name: "value"
+    description: <<END
+Any number of dimensions.
+END
+  }
+  in_arg {
+    name: "bias"
+    description: <<END
+1-D with size the last dimension of `value`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Broadcasted sum of `value` and `bias`.
+END
+  }
+  summary: "Adds `bias` to `value`."
+  description: <<END
+This is a deprecated version of BiasAdd and will be soon removed.
+
+This is a special case of `tf.add` where `bias` is restricted to be 1-D.
+Broadcasting is supported, so `value` may have any number of dimensions.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Bincount.pbtxt b/tensorflow/core/api_def/base_api/api_def_Bincount.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1016f2ff6716994fc7a047f2641dce48e48c7367
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Bincount.pbtxt
@@ -0,0 +1,40 @@
+op {
+  graph_op_name: "Bincount"
+  in_arg {
+    name: "arr"
+    description: <<END
+int32 `Tensor`.
+END
+  }
+  in_arg {
+    name: "size"
+    description: <<END
+non-negative int32 scalar `Tensor`.
+END
+  }
+  in_arg {
+    name: "weights"
+    description: <<END
+is an int32, int64, float32, or float64 `Tensor` with the same
+shape as `arr`, or a length-0 `Tensor`, in which case it acts as all weights
+equal to 1.
+END
+  }
+  out_arg {
+    name: "bins"
+    description: <<END
+1D `Tensor` with length equal to `size`. The counts or summed weights for
+each value in the range [0, size).
+END
+  }
+  summary: "Counts the number of occurrences of each value in an integer array."
+  description: <<END
+Outputs a vector with length `size` and the same dtype as `weights`. If
+`weights` are empty, then index `i` stores the number of times the value `i` is
+counted in `arr`. If `weights` are non-empty, then index `i` stores the sum of
+the value in `weights` at each index where the corresponding value in `arr` is
+`i`.
+
+Values in `arr` outside of the range [0, size) are ignored.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Bitcast.pbtxt b/tensorflow/core/api_def/base_api/api_def_Bitcast.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e4d4f9ea08e0da2f22af5d07ae34c16c84d05eee
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Bitcast.pbtxt
@@ -0,0 +1,18 @@
+op {
+  graph_op_name: "Bitcast"
+  summary: "Bitcasts a tensor from one type to another without copying data."
+  description: <<END
+Given a tensor `input`, this operation returns a tensor that has the same buffer
+data as `input` with datatype `type`.
+
+If the input datatype `T` is larger than the output datatype `type` then the
+shape changes from [...] to [..., sizeof(`T`)/sizeof(`type`)].
+
+If `T` is smaller than `type`, the operator requires that the rightmost
+dimension be equal to sizeof(`type`)/sizeof(`T`). The shape then goes from
+[..., sizeof(`type`)/sizeof(`T`)] to [...].
+
+*NOTE*: Bitcast is implemented as a low-level cast, so machines with different
+endian orderings will give different results.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BitwiseAnd.pbtxt b/tensorflow/core/api_def/base_api/api_def_BitwiseAnd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..44d34ce9ec2aa52357254ebef80b52a88a4e0eb7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BitwiseAnd.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "BitwiseAnd"
+  summary: "Elementwise computes the bitwise AND of `x` and `y`."
+  description: <<END
+The result will have those bits set, that are set in both `x` and `y`. The
+computation is performed on the underlying representations of `x` and `y`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BitwiseOr.pbtxt b/tensorflow/core/api_def/base_api/api_def_BitwiseOr.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e9c8feb40d54877ae44dd445e293ece44a3e532d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BitwiseOr.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "BitwiseOr"
+  summary: "Elementwise computes the bitwise OR of `x` and `y`."
+  description: <<END
+The result will have those bits set, that are set in `x`, `y` or both. The
+computation is performed on the underlying representations of `x` and `y`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BitwiseXor.pbtxt b/tensorflow/core/api_def/base_api/api_def_BitwiseXor.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..22be3d134ab31fd91876641fb0909ddb982cccc3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BitwiseXor.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "BitwiseXor"
+  summary: "Elementwise computes the bitwise XOR of `x` and `y`."
+  description: <<END
+The result will have those bits set, that are different in `x` and `y`. The
+computation is performed on the underlying representations of `x` and `y`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BroadcastArgs.pbtxt b/tensorflow/core/api_def/base_api/api_def_BroadcastArgs.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9c8564e2184cdf68c50e47078a7f9ecf7b7eb398
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BroadcastArgs.pbtxt
@@ -0,0 +1,11 @@
+op {
+  graph_op_name: "BroadcastArgs"
+  endpoint {
+    name: "BroadcastDynamicShape"
+  }
+  summary: "Return the shape of s0 op s1 with broadcast."
+  description: <<END
+Given `s0` and `s1`, tensors that represent shapes, compute `r0`, the
+broadcasted shape. `s0`, `s1` and `r0` are all integer vectors.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BroadcastGradientArgs.pbtxt b/tensorflow/core/api_def/base_api/api_def_BroadcastGradientArgs.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a6e4516a2690f146ce417c36dec903beaff8d7a3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_BroadcastGradientArgs.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "BroadcastGradientArgs"
+  visibility: HIDDEN
+  summary: "Return the reduction indices for computing gradients of s0 op s1 with broadcast."
+  description: <<END
+This is typically used by gradient computations for a broadcasting operation.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Bucketize.pbtxt b/tensorflow/core/api_def/base_api/api_def_Bucketize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b464af95302704339f0742ff061df103d8578990
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Bucketize.pbtxt
@@ -0,0 +1,38 @@
+op {
+  graph_op_name: "Bucketize"
+  in_arg {
+    name: "input"
+    description: <<END
+Any shape of Tensor contains with int or float type.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Same shape with 'input', each value of input replaced with bucket index.
+
+@compatibility(numpy)
+Equivalent to np.digitize.
+@end_compatibility
+END
+  }
+  attr {
+    name: "boundaries"
+    description: <<END
+A sorted list of floats gives the boundary of the buckets.
+END
+  }
+  summary: "Bucketizes \'input\' based on \'boundaries\'."
+  description: <<END
+For example, if the inputs are
+    boundaries = [0, 10, 100]
+    input = [[-5, 10000]
+             [150,   10]
+             [5,    100]]
+
+then the output will be
+    output = [[0, 3]
+              [3, 2]
+              [1, 3]]
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_C.pbtxt b/tensorflow/core/api_def/base_api/api_def_C.pbtxt
deleted file mode 100644
index 48b04b79710b70d541812400586208a26dc41124..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_C.pbtxt
+++ /dev/null
@@ -1,513 +0,0 @@
-op {
-  graph_op_name: "CTCBeamSearchDecoder"
-  endpoint {
-    name: "CTCBeamSearchDecoder"
-  }
-  summary: "Performs beam search decoding on the logits given in input."
-  description: <<END
-A note about the attribute merge_repeated: For the beam search decoder,
-this means that if consecutive entries in a beam are the same, only
-the first of these is emitted.  That is, when the top path is "A B B B B",
-"A B" is returned if merge_repeated = True but "A B B B B" is
-returned if merge_repeated = False.
-END
-}
-op {
-  graph_op_name: "CTCGreedyDecoder"
-  endpoint {
-    name: "CTCGreedyDecoder"
-  }
-  summary: "Performs greedy decoding on the logits given in inputs."
-  description: <<END
-A note about the attribute merge_repeated: if enabled, when
-consecutive logits' maximum indices are the same, only the first of
-these is emitted.  Labeling the blank '*', the sequence "A B B * B B"
-becomes "A B B" if merge_repeated = True and "A B B B B" if
-merge_repeated = False.
-
-Regardless of the value of merge_repeated, if the maximum index of a given
-time and batch corresponds to the blank, index `(num_classes - 1)`, no new
-element is emitted.
-END
-}
-op {
-  graph_op_name: "CTCLoss"
-  endpoint {
-    name: "CTCLoss"
-  }
-  summary: "Calculates the CTC Loss (log probability) for each batch entry.  Also calculates"
-  description: <<END
-the gradient.  This class performs the softmax operation for you, so inputs
-should be e.g. linear projections of outputs by an LSTM.
-END
-}
-op {
-  graph_op_name: "CacheDataset"
-  endpoint {
-    name: "CacheDataset"
-  }
-  summary: "Creates a dataset that caches elements from `input_dataset`."
-  description: <<END
-A CacheDataset will iterate over the input_dataset, and store tensors. If the
-cache already exists, the cache will be used. If the cache is inappropriate
-(e.g. cannot be opened, contains tensors of the wrong shape / size), an error
-will the returned when used.
-END
-}
-op {
-  graph_op_name: "Cast"
-  endpoint {
-    name: "Cast"
-  }
-  summary: "Cast x of type SrcT to y of DstT."
-}
-op {
-  graph_op_name: "Ceil"
-  endpoint {
-    name: "Ceil"
-  }
-  summary: "Returns element-wise smallest integer in not less than x."
-}
-op {
-  graph_op_name: "CheckNumerics"
-  endpoint {
-    name: "CheckNumerics"
-  }
-  summary: "Checks a tensor for NaN and Inf values."
-  description: <<END
-When run, reports an `InvalidArgument` error if `tensor` has any values
-that are not a number (NaN) or infinity (Inf). Otherwise, passes `tensor` as-is.
-END
-}
-op {
-  graph_op_name: "Cholesky"
-  endpoint {
-    name: "Cholesky"
-  }
-  summary: "Computes the Cholesky decomposition of one or more square matrices."
-  description: <<END
-The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
-form square matrices.
-
-The input has to be symmetric and positive definite. Only the lower-triangular
-part of the input will be used for this operation. The upper-triangular part
-will not be read.
-
-The output is a tensor of the same shape as the input
-containing the Cholesky decompositions for all input submatrices `[..., :, :]`.
-
-**Note**: The gradient computation on GPU is faster for large matrices but
-not for large batch dimensions when the submatrices are small. In this
-case it might be faster to use the CPU.
-END
-}
-op {
-  graph_op_name: "CholeskyGrad"
-  endpoint {
-    name: "CholeskyGrad"
-  }
-  summary: "Computes the reverse mode backpropagated gradient of the Cholesky algorithm."
-  description: <<END
-For an explanation see "Differentiation of the Cholesky algorithm" by
-Iain Murray http://arxiv.org/abs/1602.07527.
-END
-}
-op {
-  graph_op_name: "CompareAndBitpack"
-  endpoint {
-    name: "CompareAndBitpack"
-  }
-  summary: "Compare values of `input` to `threshold` and pack resulting bits into a `uint8`."
-  description: <<END
-Each comparison returns a boolean `true` (if `input_value > threshold`)
-or and `false` otherwise.
-
-This operation is useful for Locality-Sensitive-Hashing (LSH) and other
-algorithms that use hashing approximations of cosine and `L2` distances;
-codes can be generated from an input via:
-
-```python
-codebook_size = 50
-codebook_bits = codebook_size * 32
-codebook = tf.get_variable('codebook', [x.shape[-1].value, codebook_bits],
-                           dtype=x.dtype,
-                           initializer=tf.orthogonal_initializer())
-codes = compare_and_threshold(tf.matmul(x, codebook), threshold=0.)
-codes = tf.bitcast(codes, tf.int32)  # go from uint8 to int32
-# now codes has shape x.shape[:-1] + [codebook_size]
-```
-
-**NOTE**: Currently, the innermost dimension of the tensor must be divisible
-by 8.
-
-Given an `input` shaped `[s0, s1, ..., s_n]`, the output is
-a `uint8` tensor shaped `[s0, s1, ..., s_n / 8]`.
-END
-}
-op {
-  graph_op_name: "Complex"
-  endpoint {
-    name: "Complex"
-  }
-  summary: "Converts two real numbers to a complex number."
-  description: <<END
-Given a tensor `real` representing the real part of a complex number, and a
-tensor `imag` representing the imaginary part of a complex number, this
-operation returns complex numbers elementwise of the form \\(a + bj\\), where
-*a* represents the `real` part and *b* represents the `imag` part.
-
-The input tensors `real` and `imag` must have the same shape.
-
-For example:
-
-```
-# tensor 'real' is [2.25, 3.25]
-# tensor `imag` is [4.75, 5.75]
-tf.complex(real, imag) ==> [[2.25 + 4.75j], [3.25 + 5.75j]]
-```
-END
-}
-op {
-  graph_op_name: "ComplexAbs"
-  endpoint {
-    name: "ComplexAbs"
-  }
-  summary: "Computes the complex absolute value of a tensor."
-  description: <<END
-Given a tensor `x` of complex numbers, this operation returns a tensor of type
-`float` or `double` that is the absolute value of each element in `x`. All
-elements in `x` must be complex numbers of the form \\(a + bj\\). The absolute
-value is computed as \\( \sqrt{a^2 + b^2}\\).
-END
-}
-op {
-  graph_op_name: "ComputeAccidentalHits"
-  endpoint {
-    name: "ComputeAccidentalHits"
-  }
-  summary: "Computes the ids of the positions in sampled_candidates that match true_labels."
-  description: <<END
-When doing log-odds NCE, the result of this op should be passed through a
-SparseToDense op, then added to the logits of the sampled candidates. This has
-the effect of 'removing' the sampled labels that match the true labels by
-making the classifier sure that they are sampled labels.
-END
-}
-op {
-  graph_op_name: "Concat"
-  endpoint {
-    name: "Concat"
-  }
-  summary: "Concatenates tensors along one dimension."
-}
-op {
-  graph_op_name: "ConcatOffset"
-  endpoint {
-    name: "ConcatOffset"
-  }
-  summary: "Computes offsets of concat inputs within its output."
-  description: <<END
-For example:
-
-```
-# 'x' is [2, 2, 7]
-# 'y' is [2, 3, 7]
-# 'z' is [2, 5, 7]
-concat_offset(2, [x, y, z]) => [0, 0, 0], [0, 2, 0], [0, 5, 0]
-```
-
-This is typically used by gradient computations for a concat operation.
-END
-}
-op {
-  graph_op_name: "ConcatV2"
-  endpoint {
-    name: "ConcatV2"
-  }
-  summary: "Concatenates tensors along one dimension."
-}
-op {
-  graph_op_name: "ConcatenateDataset"
-  endpoint {
-    name: "ConcatenateDataset"
-  }
-  summary: "Creates a dataset that concatenates `input_dataset` with `another_dataset`."
-}
-op {
-  graph_op_name: "ConditionalAccumulator"
-  endpoint {
-    name: "ConditionalAccumulator"
-  }
-  summary: "A conditional accumulator for aggregating gradients."
-  description: <<END
-The accumulator accepts gradients marked with local_step greater or
-equal to the most recent global_step known to the accumulator. The
-average can be extracted from the accumulator, provided sufficient
-gradients have been accumulated. Extracting the average automatically
-resets the aggregate to 0, and increments the global_step recorded by
-the accumulator.
-END
-}
-op {
-  graph_op_name: "Conj"
-  endpoint {
-    name: "Conj"
-  }
-  summary: "Returns the complex conjugate of a complex number."
-  description: <<END
-Given a tensor `input` of complex numbers, this operation returns a tensor of
-complex numbers that are the complex conjugate of each element in `input`. The
-complex numbers in `input` must be of the form \\(a + bj\\), where *a* is the
-real part and *b* is the imaginary part.
-
-The complex conjugate returned by this operation is of the form \\(a - bj\\).
-
-For example:
-
-```
-# tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
-tf.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]
-```
-END
-}
-op {
-  graph_op_name: "Const"
-  endpoint {
-    name: "Const"
-  }
-  summary: "Returns a constant tensor."
-}
-op {
-  graph_op_name: "ControlTrigger"
-  endpoint {
-    name: "ControlTrigger"
-  }
-  summary: "Does nothing. Serves as a control trigger for scheduling."
-  description: <<END
-Only useful as a placeholder for control edges.
-END
-}
-op {
-  graph_op_name: "Conv2D"
-  endpoint {
-    name: "Conv2D"
-  }
-  summary: "Computes a 2-D convolution given 4-D `input` and `filter` tensors."
-  description: <<END
-Given an input tensor of shape `[batch, in_height, in_width, in_channels]`
-and a filter / kernel tensor of shape
-`[filter_height, filter_width, in_channels, out_channels]`, this op
-performs the following:
-
-1. Flattens the filter to a 2-D matrix with shape
-   `[filter_height * filter_width * in_channels, output_channels]`.
-2. Extracts image patches from the input tensor to form a *virtual*
-   tensor of shape `[batch, out_height, out_width,
-   filter_height * filter_width * in_channels]`.
-3. For each patch, right-multiplies the filter matrix and the image patch
-   vector.
-
-In detail, with the default NHWC format,
-
-    output[b, i, j, k] =
-        sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] *
-                        filter[di, dj, q, k]
-
-Must have `strides[0] = strides[3] = 1`.  For the most common case of the same
-horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
-END
-}
-op {
-  graph_op_name: "Conv2DBackpropFilter"
-  endpoint {
-    name: "Conv2DBackpropFilter"
-  }
-  summary: "Computes the gradients of convolution with respect to the filter."
-}
-op {
-  graph_op_name: "Conv2DBackpropInput"
-  endpoint {
-    name: "Conv2DBackpropInput"
-  }
-  summary: "Computes the gradients of convolution with respect to the input."
-}
-op {
-  graph_op_name: "Conv3D"
-  endpoint {
-    name: "Conv3D"
-  }
-  summary: "Computes a 3-D convolution given 5-D `input` and `filter` tensors."
-  description: <<END
-In signal processing, cross-correlation is a measure of similarity of
-two waveforms as a function of a time-lag applied to one of them. This
-is also known as a sliding dot product or sliding inner-product.
-
-Our Conv3D implements a form of cross-correlation.
-END
-}
-op {
-  graph_op_name: "Conv3DBackpropFilter"
-  endpoint {
-    name: "Conv3DBackpropFilter"
-  }
-  summary: "Computes the gradients of 3-D convolution with respect to the filter."
-}
-op {
-  graph_op_name: "Conv3DBackpropFilterV2"
-  endpoint {
-    name: "Conv3DBackpropFilterV2"
-  }
-  summary: "Computes the gradients of 3-D convolution with respect to the filter."
-}
-op {
-  graph_op_name: "Conv3DBackpropInput"
-  endpoint {
-    name: "Conv3DBackpropInput"
-  }
-  summary: "Computes the gradients of 3-D convolution with respect to the input."
-}
-op {
-  graph_op_name: "Conv3DBackpropInputV2"
-  endpoint {
-    name: "Conv3DBackpropInputV2"
-  }
-  summary: "Computes the gradients of 3-D convolution with respect to the input."
-}
-op {
-  graph_op_name: "Cos"
-  endpoint {
-    name: "Cos"
-  }
-  summary: "Computes cos of x element-wise."
-}
-op {
-  graph_op_name: "Cosh"
-  endpoint {
-    name: "Cosh"
-  }
-  summary: "Computes hyperbolic cosine of x element-wise."
-}
-op {
-  graph_op_name: "CountUpTo"
-  endpoint {
-    name: "CountUpTo"
-  }
-  summary: "Increments \'ref\' until it reaches \'limit\'."
-}
-op {
-  graph_op_name: "CropAndResize"
-  endpoint {
-    name: "CropAndResize"
-  }
-  summary: "Extracts crops from the input image tensor and bilinearly resizes them (possibly"
-  description: <<END
-with aspect ratio change) to a common output size specified by `crop_size`. This
-is more general than the `crop_to_bounding_box` op which extracts a fixed size
-slice from the input image and does not allow resizing or aspect ratio change.
-
-Returns a tensor with `crops` from the input `image` at positions defined at the
-bounding box locations in `boxes`. The cropped boxes are all resized (with
-bilinear interpolation) to a fixed `size = [crop_height, crop_width]`. The
-result is a 4-D tensor `[num_boxes, crop_height, crop_width, depth]`.
-END
-}
-op {
-  graph_op_name: "CropAndResizeGradBoxes"
-  endpoint {
-    name: "CropAndResizeGradBoxes"
-  }
-  summary: "Computes the gradient of the crop_and_resize op wrt the input boxes tensor."
-}
-op {
-  graph_op_name: "CropAndResizeGradImage"
-  endpoint {
-    name: "CropAndResizeGradImage"
-  }
-  summary: "Computes the gradient of the crop_and_resize op wrt the input image tensor."
-}
-op {
-  graph_op_name: "Cross"
-  endpoint {
-    name: "Cross"
-  }
-  summary: "Compute the pairwise cross product."
-  description: <<END
-`a` and `b` must be the same shape; they can either be simple 3-element vectors,
-or any shape where the innermost dimension is 3. In the latter case, each pair
-of corresponding 3-element vectors is cross-multiplied independently.
-END
-}
-op {
-  graph_op_name: "Cumprod"
-  endpoint {
-    name: "Cumprod"
-  }
-  summary: "Compute the cumulative product of the tensor `x` along `axis`."
-  description: <<END
-By default, this op performs an inclusive cumprod, which means that the first
-element of the input is identical to the first element of the output:
-
-```python
-tf.cumprod([a, b, c])  # => [a, a * b, a * b * c]
-```
-
-By setting the `exclusive` kwarg to `True`, an exclusive cumprod is
-performed instead:
-
-```python
-tf.cumprod([a, b, c], exclusive=True)  # => [1, a, a * b]
-```
-
-By setting the `reverse` kwarg to `True`, the cumprod is performed in the
-opposite direction:
-
-```python
-tf.cumprod([a, b, c], reverse=True)  # => [a * b * c, b * c, c]
-```
-
-This is more efficient than using separate `tf.reverse` ops.
-
-The `reverse` and `exclusive` kwargs can also be combined:
-
-```python
-tf.cumprod([a, b, c], exclusive=True, reverse=True)  # => [b * c, c, 1]
-```
-END
-}
-op {
-  graph_op_name: "Cumsum"
-  endpoint {
-    name: "Cumsum"
-  }
-  summary: "Compute the cumulative sum of the tensor `x` along `axis`."
-  description: <<END
-By default, this op performs an inclusive cumsum, which means that the first
-element of the input is identical to the first element of the output:
-
-```python
-tf.cumsum([a, b, c])  # => [a, a + b, a + b + c]
-```
-
-By setting the `exclusive` kwarg to `True`, an exclusive cumsum is
-performed instead:
-
-```python
-tf.cumsum([a, b, c], exclusive=True)  # => [0, a, a + b]
-```
-
-By setting the `reverse` kwarg to `True`, the cumsum is performed in the
-opposite direction:
-
-```python
-tf.cumsum([a, b, c], reverse=True)  # => [a + b + c, b + c, c]
-```
-
-This is more efficient than using separate `tf.reverse` ops.
-
-The `reverse` and `exclusive` kwargs can also be combined:
-
-```python
-tf.cumsum([a, b, c], exclusive=True, reverse=True)  # => [b + c, c, 0]
-```
-END
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_CTCBeamSearchDecoder.pbtxt b/tensorflow/core/api_def/base_api/api_def_CTCBeamSearchDecoder.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..36eb2fb7b44642b0bbf77afcc5aa3ec1f6692e03
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_CTCBeamSearchDecoder.pbtxt
@@ -0,0 +1,72 @@
+op {
+  graph_op_name: "CTCBeamSearchDecoder"
+  in_arg {
+    name: "inputs"
+    description: <<END
+3-D, shape: `(max_time x batch_size x num_classes)`, the logits.
+END
+  }
+  in_arg {
+    name: "sequence_length"
+    description: <<END
+A vector containing sequence lengths, size `(batch)`.
+END
+  }
+  out_arg {
+    name: "decoded_indices"
+    description: <<END
+A list (length: top_paths) of indices matrices.  Matrix j,
+size `(total_decoded_outputs[j] x 2)`, has indices of a
+`SparseTensor<int64, 2>`.  The rows store: [batch, time].
+END
+  }
+  out_arg {
+    name: "decoded_values"
+    description: <<END
+A list (length: top_paths) of values vectors.  Vector j,
+size `(length total_decoded_outputs[j])`, has the values of a
+`SparseTensor<int64, 2>`.  The vector stores the decoded classes for beam j.
+END
+  }
+  out_arg {
+    name: "decoded_shape"
+    description: <<END
+A list (length: top_paths) of shape vector.  Vector j,
+size `(2)`, stores the shape of the decoded `SparseTensor[j]`.
+Its values are: `[batch_size, max_decoded_length[j]]`.
+END
+  }
+  out_arg {
+    name: "log_probability"
+    description: <<END
+A matrix, shaped: `(batch_size x top_paths)`.  The
+sequence log-probabilities.
+END
+  }
+  attr {
+    name: "beam_width"
+    description: <<END
+A scalar >= 0 (beam search beam width).
+END
+  }
+  attr {
+    name: "top_paths"
+    description: <<END
+A scalar >= 0, <= beam_width (controls output size).
+END
+  }
+  attr {
+    name: "merge_repeated"
+    description: <<END
+If true, merge repeated classes in output.
+END
+  }
+  summary: "Performs beam search decoding on the logits given in input."
+  description: <<END
+A note about the attribute merge_repeated: For the beam search decoder,
+this means that if consecutive entries in a beam are the same, only
+the first of these is emitted.  That is, when the top path is "A B B B B",
+"A B" is returned if merge_repeated = True but "A B B B B" is
+returned if merge_repeated = False.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_CTCGreedyDecoder.pbtxt b/tensorflow/core/api_def/base_api/api_def_CTCGreedyDecoder.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..814f5350a2ec21731a08a607e7cc12090377285d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_CTCGreedyDecoder.pbtxt
@@ -0,0 +1,61 @@
+op {
+  graph_op_name: "CTCGreedyDecoder"
+  in_arg {
+    name: "inputs"
+    description: <<END
+3-D, shape: `(max_time x batch_size x num_classes)`, the logits.
+END
+  }
+  in_arg {
+    name: "sequence_length"
+    description: <<END
+A vector containing sequence lengths, size `(batch_size)`.
+END
+  }
+  out_arg {
+    name: "decoded_indices"
+    description: <<END
+Indices matrix, size `(total_decoded_outputs x 2)`,
+of a `SparseTensor<int64, 2>`.  The rows store: [batch, time].
+END
+  }
+  out_arg {
+    name: "decoded_values"
+    description: <<END
+Values vector, size: `(total_decoded_outputs)`,
+of a `SparseTensor<int64, 2>`.  The vector stores the decoded classes.
+END
+  }
+  out_arg {
+    name: "decoded_shape"
+    description: <<END
+Shape vector, size `(2)`, of the decoded SparseTensor.
+Values are: `[batch_size, max_decoded_length]`.
+END
+  }
+  out_arg {
+    name: "log_probability"
+    description: <<END
+Matrix, size `(batch_size x 1)`, containing sequence
+log-probabilities.
+END
+  }
+  attr {
+    name: "merge_repeated"
+    description: <<END
+If True, merge repeated classes in output.
+END
+  }
+  summary: "Performs greedy decoding on the logits given in inputs."
+  description: <<END
+A note about the attribute merge_repeated: if enabled, when
+consecutive logits' maximum indices are the same, only the first of
+these is emitted.  Labeling the blank '*', the sequence "A B B * B B"
+becomes "A B B" if merge_repeated = True and "A B B B B" if
+merge_repeated = False.
+
+Regardless of the value of merge_repeated, if the maximum index of a given
+time and batch corresponds to the blank, index `(num_classes - 1)`, no new
+element is emitted.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_CTCLoss.pbtxt b/tensorflow/core/api_def/base_api/api_def_CTCLoss.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a85597ae6ec2cc7bce550b54aa10fc6ec04d5dcb
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_CTCLoss.pbtxt
@@ -0,0 +1,70 @@
+op {
+  graph_op_name: "CTCLoss"
+  in_arg {
+    name: "inputs"
+    description: <<END
+3-D, shape: `(max_time x batch_size x num_classes)`, the logits.
+END
+  }
+  in_arg {
+    name: "labels_indices"
+    description: <<END
+The indices of a `SparseTensor<int32, 2>`.
+`labels_indices(i, :) == [b, t]` means `labels_values(i)` stores the id for
+`(batch b, time t)`.
+END
+  }
+  in_arg {
+    name: "labels_values"
+    description: <<END
+The values (labels) associated with the given batch and time.
+END
+  }
+  in_arg {
+    name: "sequence_length"
+    description: <<END
+A vector containing sequence lengths (batch).
+END
+  }
+  out_arg {
+    name: "loss"
+    description: <<END
+A vector (batch) containing log-probabilities.
+END
+  }
+  out_arg {
+    name: "gradient"
+    description: <<END
+The gradient of `loss`.  3-D, shape:
+`(max_time x batch_size x num_classes)`.
+END
+  }
+  attr {
+    name: "preprocess_collapse_repeated"
+    description: <<END
+Scalar, if true then repeated labels are
+collapsed prior to the CTC calculation.
+END
+  }
+  attr {
+    name: "ctc_merge_repeated"
+    description: <<END
+Scalar.  If set to false, *during* CTC calculation
+repeated non-blank labels will not be merged and are interpreted as
+individual labels.  This is a simplified version of CTC.
+END
+  }
+  attr {
+    name: "ignore_longer_outputs_than_inputs"
+    description: <<END
+Scalar. If set to true, during CTC
+calculation, items that have longer output sequences than input sequences
+are skipped: they don't contribute to the loss term and have zero-gradient.
+END
+  }
+  summary: "Calculates the CTC Loss (log probability) for each batch entry.  Also calculates"
+  description: <<END
+the gradient.  This class performs the softmax operation for you, so inputs
+should be e.g. linear projections of outputs by an LSTM.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_CacheDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_CacheDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6889b8ea148b57da847964c062bd52b1027b8d22
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_CacheDataset.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "CacheDataset"
+  in_arg {
+    name: "filename"
+    description: <<END
+A path on the filesystem where we should cache the dataset. Note: this
+will be a directory.
+END
+  }
+  summary: "Creates a dataset that caches elements from `input_dataset`."
+  description: <<END
+A CacheDataset will iterate over the input_dataset, and store tensors. If the
+cache already exists, the cache will be used. If the cache is inappropriate
+(e.g. cannot be opened, contains tensors of the wrong shape / size), an error
+will the returned when used.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Cast.pbtxt b/tensorflow/core/api_def/base_api/api_def_Cast.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8a0ba505cbaf6bf37be8a1dcb17928117ac89891
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Cast.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Cast"
+  summary: "Cast x of type SrcT to y of DstT."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Ceil.pbtxt b/tensorflow/core/api_def/base_api/api_def_Ceil.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ad1ada8d717a51ee3a058da5d32ed7bf50375b13
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Ceil.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Ceil"
+  summary: "Returns element-wise smallest integer in not less than x."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_CheckNumerics.pbtxt b/tensorflow/core/api_def/base_api/api_def_CheckNumerics.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cadf3667e2bc487d83911734281346eefdf88252
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_CheckNumerics.pbtxt
@@ -0,0 +1,14 @@
+op {
+  graph_op_name: "CheckNumerics"
+  attr {
+    name: "message"
+    description: <<END
+Prefix of the error message.
+END
+  }
+  summary: "Checks a tensor for NaN and Inf values."
+  description: <<END
+When run, reports an `InvalidArgument` error if `tensor` has any values
+that are not a number (NaN) or infinity (Inf). Otherwise, passes `tensor` as-is.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Cholesky.pbtxt b/tensorflow/core/api_def/base_api/api_def_Cholesky.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..713abee6309e73bda6b85b1742885c9768a66134
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Cholesky.pbtxt
@@ -0,0 +1,31 @@
+op {
+  graph_op_name: "Cholesky"
+  in_arg {
+    name: "input"
+    description: <<END
+Shape is `[..., M, M]`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Shape is `[..., M, M]`.
+END
+  }
+  summary: "Computes the Cholesky decomposition of one or more square matrices."
+  description: <<END
+The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+form square matrices.
+
+The input has to be symmetric and positive definite. Only the lower-triangular
+part of the input will be used for this operation. The upper-triangular part
+will not be read.
+
+The output is a tensor of the same shape as the input
+containing the Cholesky decompositions for all input submatrices `[..., :, :]`.
+
+**Note**: The gradient computation on GPU is faster for large matrices but
+not for large batch dimensions when the submatrices are small. In this
+case it might be faster to use the CPU.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_CholeskyGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_CholeskyGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..faf5e274b340a40d58cac3315b2b3b9a0b29a0b9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_CholeskyGrad.pbtxt
@@ -0,0 +1,30 @@
+op {
+  graph_op_name: "CholeskyGrad"
+  in_arg {
+    name: "l"
+    description: <<END
+Output of batch Cholesky algorithm l = cholesky(A). Shape is `[..., M, M]`.
+Algorithm depends only on lower triangular part of the innermost matrices of
+this tensor.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+df/dl where f is some scalar function. Shape is `[..., M, M]`.
+Algorithm depends only on lower triangular part of the innermost matrices of
+this tensor.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Symmetrized version of df/dA . Shape is `[..., M, M]`
+END
+  }
+  summary: "Computes the reverse mode backpropagated gradient of the Cholesky algorithm."
+  description: <<END
+For an explanation see "Differentiation of the Cholesky algorithm" by
+Iain Murray http://arxiv.org/abs/1602.07527.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_CompareAndBitpack.pbtxt b/tensorflow/core/api_def/base_api/api_def_CompareAndBitpack.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..57ba4f8f4c49d4cddf3681fd1cc79a0faad74259
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_CompareAndBitpack.pbtxt
@@ -0,0 +1,53 @@
+op {
+  graph_op_name: "CompareAndBitpack"
+  in_arg {
+    name: "input"
+    description: <<END
+Values to compare against `threshold` and bitpack.
+END
+  }
+  in_arg {
+    name: "threshold"
+    description: <<END
+Threshold to compare against.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The bitpacked comparisons.
+END
+  }
+  attr {
+    name: "T"
+    description: <<END
+The type of the input and threshold.
+END
+  }
+  summary: "Compare values of `input` to `threshold` and pack resulting bits into a `uint8`."
+  description: <<END
+Each comparison returns a boolean `true` (if `input_value > threshold`)
+or and `false` otherwise.
+
+This operation is useful for Locality-Sensitive-Hashing (LSH) and other
+algorithms that use hashing approximations of cosine and `L2` distances;
+codes can be generated from an input via:
+
+```python
+codebook_size = 50
+codebook_bits = codebook_size * 32
+codebook = tf.get_variable('codebook', [x.shape[-1].value, codebook_bits],
+                           dtype=x.dtype,
+                           initializer=tf.orthogonal_initializer())
+codes = compare_and_threshold(tf.matmul(x, codebook), threshold=0.)
+codes = tf.bitcast(codes, tf.int32)  # go from uint8 to int32
+# now codes has shape x.shape[:-1] + [codebook_size]
+```
+
+**NOTE**: Currently, the innermost dimension of the tensor must be divisible
+by 8.
+
+Given an `input` shaped `[s0, s1, ..., s_n]`, the output is
+a `uint8` tensor shaped `[s0, s1, ..., s_n / 8]`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Complex.pbtxt b/tensorflow/core/api_def/base_api/api_def_Complex.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e421d8ce0bd64b4b3a6db09393e7d5c4955e373a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Complex.pbtxt
@@ -0,0 +1,20 @@
+op {
+  graph_op_name: "Complex"
+  summary: "Converts two real numbers to a complex number."
+  description: <<END
+Given a tensor `real` representing the real part of a complex number, and a
+tensor `imag` representing the imaginary part of a complex number, this
+operation returns complex numbers elementwise of the form \\(a + bj\\), where
+*a* represents the `real` part and *b* represents the `imag` part.
+
+The input tensors `real` and `imag` must have the same shape.
+
+For example:
+
+```
+# tensor 'real' is [2.25, 3.25]
+# tensor `imag` is [4.75, 5.75]
+tf.complex(real, imag) ==> [[2.25 + 4.75j], [3.25 + 5.75j]]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ComplexAbs.pbtxt b/tensorflow/core/api_def/base_api/api_def_ComplexAbs.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..19088f5dfcde375236bf46d364a9e0a41211eab3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ComplexAbs.pbtxt
@@ -0,0 +1,10 @@
+op {
+  graph_op_name: "ComplexAbs"
+  summary: "Computes the complex absolute value of a tensor."
+  description: <<END
+Given a tensor `x` of complex numbers, this operation returns a tensor of type
+`float` or `double` that is the absolute value of each element in `x`. All
+elements in `x` must be complex numbers of the form \\(a + bj\\). The absolute
+value is computed as \\( \sqrt{a^2 + b^2}\\).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ComputeAccidentalHits.pbtxt b/tensorflow/core/api_def/base_api/api_def_ComputeAccidentalHits.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8cf1e8054205dc75d2b9ace36b26dee33ea4651f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ComputeAccidentalHits.pbtxt
@@ -0,0 +1,62 @@
+op {
+  graph_op_name: "ComputeAccidentalHits"
+  in_arg {
+    name: "true_classes"
+    description: <<END
+The true_classes output of UnpackSparseLabels.
+END
+  }
+  in_arg {
+    name: "sampled_candidates"
+    description: <<END
+The sampled_candidates output of CandidateSampler.
+END
+  }
+  out_arg {
+    name: "indices"
+    description: <<END
+A vector of indices corresponding to rows of true_candidates.
+END
+  }
+  out_arg {
+    name: "ids"
+    description: <<END
+A vector of IDs of positions in sampled_candidates that match a true_label
+for the row with the corresponding index in indices.
+END
+  }
+  out_arg {
+    name: "weights"
+    description: <<END
+A vector of the same length as indices and ids, in which each element
+is -FLOAT_MAX.
+END
+  }
+  attr {
+    name: "num_true"
+    description: <<END
+Number of true labels per context.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either seed or seed2 are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+An second seed to avoid seed collision.
+END
+  }
+  summary: "Computes the ids of the positions in sampled_candidates that match true_labels."
+  description: <<END
+When doing log-odds NCE, the result of this op should be passed through a
+SparseToDense op, then added to the logits of the sampled candidates. This has
+the effect of 'removing' the sampled labels that match the true labels by
+making the classifier sure that they are sampled labels.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Concat.pbtxt b/tensorflow/core/api_def/base_api/api_def_Concat.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1bad600e5bfb579fd960c8ac3a61e7754dc78b48
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Concat.pbtxt
@@ -0,0 +1,27 @@
+op {
+  graph_op_name: "Concat"
+  visibility: SKIP
+  in_arg {
+    name: "concat_dim"
+    description: <<END
+0-D.  The dimension along which to concatenate.  Must be in the
+range [0, rank(values)).
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+The `N` Tensors to concatenate. Their ranks and types must match,
+and their sizes must match in all dimensions except `concat_dim`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A `Tensor` with the concatenation of values stacked along the
+`concat_dim` dimension.  This tensor's shape matches that of `values` except
+in `concat_dim` where it has the sum of the sizes.
+END
+  }
+  summary: "Concatenates tensors along one dimension."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ConcatOffset.pbtxt b/tensorflow/core/api_def/base_api/api_def_ConcatOffset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..84b11715ceedfe5d7959793813a07cca806ffcad
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ConcatOffset.pbtxt
@@ -0,0 +1,36 @@
+op {
+  graph_op_name: "ConcatOffset"
+  visibility: SKIP
+  in_arg {
+    name: "concat_dim"
+    description: <<END
+The dimension along which to concatenate.
+END
+  }
+  in_arg {
+    name: "shape"
+    description: <<END
+The `N` int32 vectors representing shape of tensors being concatenated.
+END
+  }
+  out_arg {
+    name: "offset"
+    description: <<END
+The `N` int32 vectors representing the starting offset
+of input tensors within the concatenated output.
+END
+  }
+  summary: "Computes offsets of concat inputs within its output."
+  description: <<END
+For example:
+
+```
+# 'x' is [2, 2, 7]
+# 'y' is [2, 3, 7]
+# 'z' is [2, 5, 7]
+concat_offset(2, [x, y, z]) => [0, 0, 0], [0, 2, 0], [0, 5, 0]
+```
+
+This is typically used by gradient computations for a concat operation.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ConcatV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_ConcatV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f1a7a81c73882b23b47d6c93fe147a39e89c49da
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ConcatV2.pbtxt
@@ -0,0 +1,29 @@
+op {
+  graph_op_name: "ConcatV2"
+  endpoint {
+    name: "Concat"
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+List of `N` Tensors to concatenate. Their ranks and types must match,
+and their sizes must match in all dimensions except `concat_dim`.
+END
+  }
+  in_arg {
+    name: "axis"
+    description: <<END
+0-D.  The dimension along which to concatenate.  Must be in the
+range [-rank(values), rank(values)).
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A `Tensor` with the concatenation of values stacked along the
+`concat_dim` dimension.  This tensor's shape matches that of `values` except
+in `concat_dim` where it has the sum of the sizes.
+END
+  }
+  summary: "Concatenates tensors along one dimension."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ConcatenateDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_ConcatenateDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..67281f9547ac6bb9df5b19e9f31da891454993bd
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ConcatenateDataset.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ConcatenateDataset"
+  summary: "Creates a dataset that concatenates `input_dataset` with `another_dataset`."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ConditionalAccumulator.pbtxt b/tensorflow/core/api_def/base_api/api_def_ConditionalAccumulator.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..64672e0e58737545d021f45371f8d4d443d3a860
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ConditionalAccumulator.pbtxt
@@ -0,0 +1,44 @@
+op {
+  graph_op_name: "ConditionalAccumulator"
+  out_arg {
+    name: "handle"
+    description: <<END
+The handle to the accumulator.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of the value being accumulated.
+END
+  }
+  attr {
+    name: "shape"
+    description: <<END
+The shape of the values, can be [], in which case shape is unknown.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this accumulator is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this accumulator will be shared under the
+given name across multiple sessions.
+END
+  }
+  summary: "A conditional accumulator for aggregating gradients."
+  description: <<END
+The accumulator accepts gradients marked with local_step greater or
+equal to the most recent global_step known to the accumulator. The
+average can be extracted from the accumulator, provided sufficient
+gradients have been accumulated. Extracting the average automatically
+resets the aggregate to 0, and increments the global_step recorded by
+the accumulator.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Conj.pbtxt b/tensorflow/core/api_def/base_api/api_def_Conj.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e161dc5b154616abfbce218163fa1442bc29f9ff
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Conj.pbtxt
@@ -0,0 +1,19 @@
+op {
+  graph_op_name: "Conj"
+  summary: "Returns the complex conjugate of a complex number."
+  description: <<END
+Given a tensor `input` of complex numbers, this operation returns a tensor of
+complex numbers that are the complex conjugate of each element in `input`. The
+complex numbers in `input` must be of the form \\(a + bj\\), where *a* is the
+real part and *b* is the imaginary part.
+
+The complex conjugate returned by this operation is of the form \\(a - bj\\).
+
+For example:
+
+```
+# tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
+tf.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ConjugateTranspose.pbtxt b/tensorflow/core/api_def/base_api/api_def_ConjugateTranspose.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..508c7a8bff5c1fe7e7641163b370a728a0ba6878
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ConjugateTranspose.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "ConjugateTranspose"
+  summary: "Shuffle dimensions of x according to a permutation and conjugate the result."
+  description: <<END
+The output `y` has the same rank as `x`. The shapes of `x` and `y` satisfy:
+  `y.shape[i] == x.shape[perm[i]] for i in [0, 1, ..., rank(x) - 1]`
+  `y[i,j,k,...,s,t,u] == conj(x[perm[i], perm[j], perm[k],...,perm[s], perm[t], perm[u]])`
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Const.pbtxt b/tensorflow/core/api_def/base_api/api_def_Const.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0d9e909f89a4de4665aa6a7dcd749b422ddc4498
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Const.pbtxt
@@ -0,0 +1,10 @@
+op {
+  graph_op_name: "Const"
+  attr {
+    name: "value"
+    description: <<END
+Attr `value` is the tensor to return.
+END
+  }
+  summary: "Returns a constant tensor."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ControlTrigger.pbtxt b/tensorflow/core/api_def/base_api/api_def_ControlTrigger.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9902e3a784b1982f5db73271b20b16a4eaa63ce3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ControlTrigger.pbtxt
@@ -0,0 +1,7 @@
+op {
+  graph_op_name: "ControlTrigger"
+  summary: "Does nothing. Serves as a control trigger for scheduling."
+  description: <<END
+Only useful as a placeholder for control edges.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Conv2D.pbtxt b/tensorflow/core/api_def/base_api/api_def_Conv2D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6522ce976f2b507c4c66d4d3709427b5fa8222e9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Conv2D.pbtxt
@@ -0,0 +1,72 @@
+op {
+  graph_op_name: "Conv2D"
+  in_arg {
+    name: "input"
+    description: <<END
+A 4-D tensor. The dimension order is interpreted according to the value
+of `data_format`, see below for details.
+END
+  }
+  in_arg {
+    name: "filter"
+    description: <<END
+A 4-D tensor of shape
+`[filter_height, filter_width, in_channels, out_channels]`
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A 4-D tensor. The dimension order is determined by the value of
+`data_format`, see below for details.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+1-D tensor of length 4.  The stride of the sliding window for each
+dimension of `input`. The dimension order is determined by the value of
+  `data_format`, see below for details.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+Specify the data format of the input and output data. With the
+default format "NHWC", the data is stored in the order of:
+    [batch, height, width, channels].
+Alternatively, the format could be "NCHW", the data storage order of:
+    [batch, channels, height, width].
+END
+  }
+  summary: "Computes a 2-D convolution given 4-D `input` and `filter` tensors."
+  description: <<END
+Given an input tensor of shape `[batch, in_height, in_width, in_channels]`
+and a filter / kernel tensor of shape
+`[filter_height, filter_width, in_channels, out_channels]`, this op
+performs the following:
+
+1. Flattens the filter to a 2-D matrix with shape
+   `[filter_height * filter_width * in_channels, output_channels]`.
+2. Extracts image patches from the input tensor to form a *virtual*
+   tensor of shape `[batch, out_height, out_width,
+   filter_height * filter_width * in_channels]`.
+3. For each patch, right-multiplies the filter matrix and the image patch
+   vector.
+
+In detail, with the default NHWC format,
+
+    output[b, i, j, k] =
+        sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] *
+                        filter[di, dj, q, k]
+
+Must have `strides[0] = strides[3] = 1`.  For the most common case of the same
+horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Conv2DBackpropFilter.pbtxt b/tensorflow/core/api_def/base_api/api_def_Conv2DBackpropFilter.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4ea3374dbbc8c690143a3a7a5fb9e67aca5bf1b0
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Conv2DBackpropFilter.pbtxt
@@ -0,0 +1,57 @@
+op {
+  graph_op_name: "Conv2DBackpropFilter"
+  in_arg {
+    name: "input"
+    description: <<END
+4-D with shape `[batch, in_height, in_width, in_channels]`.
+END
+  }
+  in_arg {
+    name: "filter_sizes"
+    description: <<END
+An integer vector representing the tensor shape of `filter`,
+where `filter` is a 4-D
+`[filter_height, filter_width, in_channels, out_channels]` tensor.
+END
+  }
+  in_arg {
+    name: "out_backprop"
+    description: <<END
+4-D with shape `[batch, out_height, out_width, out_channels]`.
+Gradients w.r.t. the output of the convolution.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+4-D with shape
+`[filter_height, filter_width, in_channels, out_channels]`.  Gradient w.r.t.
+the `filter` input of the convolution.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the input
+of the convolution. Must be in the same order as the dimension specified with
+format.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+Specify the data format of the input and output data. With the
+default format "NHWC", the data is stored in the order of:
+    [batch, in_height, in_width, in_channels].
+Alternatively, the format could be "NCHW", the data storage order of:
+    [batch, in_channels, in_height, in_width].
+END
+  }
+  summary: "Computes the gradients of convolution with respect to the filter."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Conv2DBackpropInput.pbtxt b/tensorflow/core/api_def/base_api/api_def_Conv2DBackpropInput.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4420073e384c1c24d3109b8c6c4cadb59e9ed9d0
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Conv2DBackpropInput.pbtxt
@@ -0,0 +1,56 @@
+op {
+  graph_op_name: "Conv2DBackpropInput"
+  in_arg {
+    name: "input_sizes"
+    description: <<END
+An integer vector representing the shape of `input`,
+where `input` is a 4-D `[batch, height, width, channels]` tensor.
+END
+  }
+  in_arg {
+    name: "filter"
+    description: <<END
+4-D with shape
+`[filter_height, filter_width, in_channels, out_channels]`.
+END
+  }
+  in_arg {
+    name: "out_backprop"
+    description: <<END
+4-D with shape `[batch, out_height, out_width, out_channels]`.
+Gradients w.r.t. the output of the convolution.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+4-D with shape `[batch, in_height, in_width, in_channels]`.  Gradient
+w.r.t. the input of the convolution.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the input
+of the convolution. Must be in the same order as the dimension specified with
+format.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+Specify the data format of the input and output data. With the
+default format "NHWC", the data is stored in the order of:
+    [batch, in_height, in_width, in_channels].
+Alternatively, the format could be "NCHW", the data storage order of:
+    [batch, in_channels, in_height, in_width].
+END
+  }
+  summary: "Computes the gradients of convolution with respect to the input."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Conv3D.pbtxt b/tensorflow/core/api_def/base_api/api_def_Conv3D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8f3cd4493c7af152c7a4eab78d1f96e02e325bbc
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Conv3D.pbtxt
@@ -0,0 +1,47 @@
+op {
+  graph_op_name: "Conv3D"
+  in_arg {
+    name: "input"
+    description: <<END
+Shape `[batch, in_depth, in_height, in_width, in_channels]`.
+END
+  }
+  in_arg {
+    name: "filter"
+    description: <<END
+Shape `[filter_depth, filter_height, filter_width, in_channels,
+out_channels]`. `in_channels` must match between `input` and `filter`.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+1-D tensor of length 5. The stride of the sliding window for each
+dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+The data format of the input and output data. With the
+default format "NDHWC", the data is stored in the order of:
+    [batch, in_depth, in_height, in_width, in_channels].
+Alternatively, the format could be "NCDHW", the data storage order is:
+    [batch, in_channels, in_depth, in_height, in_width].
+END
+  }
+  summary: "Computes a 3-D convolution given 5-D `input` and `filter` tensors."
+  description: <<END
+In signal processing, cross-correlation is a measure of similarity of
+two waveforms as a function of a time-lag applied to one of them. This
+is also known as a sliding dot product or sliding inner-product.
+
+Our Conv3D implements a form of cross-correlation.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Conv3DBackpropFilter.pbtxt b/tensorflow/core/api_def/base_api/api_def_Conv3DBackpropFilter.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3da4a878651a1e88e6c149c2e620089be489d1b3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Conv3DBackpropFilter.pbtxt
@@ -0,0 +1,37 @@
+op {
+  graph_op_name: "Conv3DBackpropFilter"
+  in_arg {
+    name: "input"
+    description: <<END
+Shape `[batch, depth, rows, cols, in_channels]`.
+END
+  }
+  in_arg {
+    name: "filter"
+    description: <<END
+Shape `[depth, rows, cols, in_channels, out_channels]`.
+`in_channels` must match between `input` and `filter`.
+END
+  }
+  in_arg {
+    name: "out_backprop"
+    description: <<END
+Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
+out_channels]`.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+1-D tensor of length 5. The stride of the sliding window for each
+dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  summary: "Computes the gradients of 3-D convolution with respect to the filter."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Conv3DBackpropFilterV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_Conv3DBackpropFilterV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6f9b917237b5748ac91c0a3bfbe35a21954dfd9d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Conv3DBackpropFilterV2.pbtxt
@@ -0,0 +1,49 @@
+op {
+  graph_op_name: "Conv3DBackpropFilterV2"
+  in_arg {
+    name: "input"
+    description: <<END
+Shape `[batch, depth, rows, cols, in_channels]`.
+END
+  }
+  in_arg {
+    name: "filter_sizes"
+    description: <<END
+An integer vector representing the tensor shape of `filter`,
+where `filter` is a 5-D
+`[filter_depth, filter_height, filter_width, in_channels, out_channels]`
+tensor.
+END
+  }
+  in_arg {
+    name: "out_backprop"
+    description: <<END
+Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
+out_channels]`.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+1-D tensor of length 5. The stride of the sliding window for each
+dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+The data format of the input and output data. With the
+default format "NDHWC", the data is stored in the order of:
+    [batch, in_depth, in_height, in_width, in_channels].
+Alternatively, the format could be "NCDHW", the data storage order is:
+    [batch, in_channels, in_depth, in_height, in_width].
+END
+  }
+  summary: "Computes the gradients of 3-D convolution with respect to the filter."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Conv3DBackpropInput.pbtxt b/tensorflow/core/api_def/base_api/api_def_Conv3DBackpropInput.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c40a9a91a50c30d17d6ec22c3229bd88c5fe8535
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Conv3DBackpropInput.pbtxt
@@ -0,0 +1,37 @@
+op {
+  graph_op_name: "Conv3DBackpropInput"
+  in_arg {
+    name: "input"
+    description: <<END
+Shape `[batch, depth, rows, cols, in_channels]`.
+END
+  }
+  in_arg {
+    name: "filter"
+    description: <<END
+Shape `[depth, rows, cols, in_channels, out_channels]`.
+`in_channels` must match between `input` and `filter`.
+END
+  }
+  in_arg {
+    name: "out_backprop"
+    description: <<END
+Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
+out_channels]`.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+1-D tensor of length 5. The stride of the sliding window for each
+dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  summary: "Computes the gradients of 3-D convolution with respect to the input."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Conv3DBackpropInputV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_Conv3DBackpropInputV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..19aba156d5907eb79d1438c16f866dfbd99ed548
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Conv3DBackpropInputV2.pbtxt
@@ -0,0 +1,49 @@
+op {
+  graph_op_name: "Conv3DBackpropInputV2"
+  in_arg {
+    name: "input_sizes"
+    description: <<END
+An integer vector representing the tensor shape of `input`,
+where `input` is a 5-D
+`[batch, depth, rows, cols, in_channels]` tensor.
+END
+  }
+  in_arg {
+    name: "filter"
+    description: <<END
+Shape `[depth, rows, cols, in_channels, out_channels]`.
+`in_channels` must match between `input` and `filter`.
+END
+  }
+  in_arg {
+    name: "out_backprop"
+    description: <<END
+Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
+out_channels]`.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+1-D tensor of length 5. The stride of the sliding window for each
+dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+The data format of the input and output data. With the
+default format "NDHWC", the data is stored in the order of:
+    [batch, in_depth, in_height, in_width, in_channels].
+Alternatively, the format could be "NCDHW", the data storage order is:
+    [batch, in_channels, in_depth, in_height, in_width].
+END
+  }
+  summary: "Computes the gradients of 3-D convolution with respect to the input."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Cos.pbtxt b/tensorflow/core/api_def/base_api/api_def_Cos.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..43fb75836f2b68388275e166f52c9e8a65bcbc17
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Cos.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Cos"
+  summary: "Computes cos of x element-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Cosh.pbtxt b/tensorflow/core/api_def/base_api/api_def_Cosh.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..aaeb4ccbd50468ef2e7bac6a5a10098c5539a7a6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Cosh.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Cosh"
+  summary: "Computes hyperbolic cosine of x element-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_CountUpTo.pbtxt b/tensorflow/core/api_def/base_api/api_def_CountUpTo.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e7b5e2901ab6af6fe71dfdf4f43d0dbffe1b4e1c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_CountUpTo.pbtxt
@@ -0,0 +1,24 @@
+op {
+  graph_op_name: "CountUpTo"
+  in_arg {
+    name: "ref"
+    description: <<END
+Should be from a scalar `Variable` node.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A copy of the input before increment. If nothing else modifies the
+input, the values produced will all be distinct.
+END
+  }
+  attr {
+    name: "limit"
+    description: <<END
+If incrementing ref would bring it above limit, instead generates an
+'OutOfRange' error.
+END
+  }
+  summary: "Increments \'ref\' until it reaches \'limit\'."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_CropAndResize.pbtxt b/tensorflow/core/api_def/base_api/api_def_CropAndResize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..629f575d0a25ceb97dedb4e94f84e3204450da6a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_CropAndResize.pbtxt
@@ -0,0 +1,74 @@
+op {
+  graph_op_name: "CropAndResize"
+  in_arg {
+    name: "image"
+    description: <<END
+A 4-D tensor of shape `[batch, image_height, image_width, depth]`.
+Both `image_height` and `image_width` need to be positive.
+END
+  }
+  in_arg {
+    name: "boxes"
+    description: <<END
+A 2-D tensor of shape `[num_boxes, 4]`. The `i`-th row of the tensor
+specifies the coordinates of a box in the `box_ind[i]` image and is specified
+in normalized coordinates `[y1, x1, y2, x2]`. A normalized coordinate value of
+`y` is mapped to the image coordinate at `y * (image_height - 1)`, so as the
+`[0, 1]` interval of normalized image height is mapped to
+`[0, image_height - 1]` in image height coordinates. We do allow `y1` > `y2`, in
+which case the sampled crop is an up-down flipped version of the original
+image. The width dimension is treated similarly. Normalized coordinates
+outside the `[0, 1]` range are allowed, in which case we use
+`extrapolation_value` to extrapolate the input image values.
+END
+  }
+  in_arg {
+    name: "box_ind"
+    description: <<END
+A 1-D tensor of shape `[num_boxes]` with int32 values in `[0, batch)`.
+The value of `box_ind[i]` specifies the image that the `i`-th box refers to.
+END
+  }
+  in_arg {
+    name: "crop_size"
+    description: <<END
+A 1-D tensor of 2 elements, `size = [crop_height, crop_width]`. All
+cropped image patches are resized to this size. The aspect ratio of the image
+content is not preserved. Both `crop_height` and `crop_width` need to be
+positive.
+END
+  }
+  out_arg {
+    name: "crops"
+    description: <<END
+A 4-D tensor of shape `[num_boxes, crop_height, crop_width, depth]`.
+END
+  }
+  attr {
+    name: "method"
+    description: <<END
+A string specifying the interpolation method. Only 'bilinear' is
+supported for now.
+END
+  }
+  attr {
+    name: "extrapolation_value"
+    description: <<END
+Value used for extrapolation, when applicable.
+END
+  }
+  summary: "Extracts crops from the input image tensor and bilinearly resizes them (possibly"
+  description: <<END
+with aspect ratio change) to a common output size specified by `crop_size`. This
+is more general than the `crop_to_bounding_box` op which extracts a fixed size
+slice from the input image and does not allow resizing or aspect ratio change.
+
+Returns a tensor with `crops` from the input `image` at positions defined at the
+bounding box locations in `boxes`. The cropped boxes are all resized (with
+bilinear interpolation) to a fixed `size = [crop_height, crop_width]`. The
+result is a 4-D tensor `[num_boxes, crop_height, crop_width, depth]`. The
+resizing is corner aligned. In particular, if `boxes = [[0, 0, 1, 1]]`, the
+method will give identical results to using `tf.image.resize_bilinear()`
+with `align_corners=True`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_CropAndResizeGradBoxes.pbtxt b/tensorflow/core/api_def/base_api/api_def_CropAndResizeGradBoxes.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c03b233efc9f3c428d0e1ac4b9399f176b351b08
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_CropAndResizeGradBoxes.pbtxt
@@ -0,0 +1,52 @@
+op {
+  graph_op_name: "CropAndResizeGradBoxes"
+  in_arg {
+    name: "grads"
+    description: <<END
+A 4-D tensor of shape `[num_boxes, crop_height, crop_width, depth]`.
+END
+  }
+  in_arg {
+    name: "image"
+    description: <<END
+A 4-D tensor of shape `[batch, image_height, image_width, depth]`.
+Both `image_height` and `image_width` need to be positive.
+END
+  }
+  in_arg {
+    name: "boxes"
+    description: <<END
+A 2-D tensor of shape `[num_boxes, 4]`. The `i`-th row of the tensor
+specifies the coordinates of a box in the `box_ind[i]` image and is specified
+in normalized coordinates `[y1, x1, y2, x2]`. A normalized coordinate value of
+`y` is mapped to the image coordinate at `y * (image_height - 1)`, so as the
+`[0, 1]` interval of normalized image height is mapped to
+`[0, image_height - 1] in image height coordinates. We do allow y1 > y2, in
+which case the sampled crop is an up-down flipped version of the original
+image. The width dimension is treated similarly. Normalized coordinates
+outside the `[0, 1]` range are allowed, in which case we use
+`extrapolation_value` to extrapolate the input image values.
+END
+  }
+  in_arg {
+    name: "box_ind"
+    description: <<END
+A 1-D tensor of shape `[num_boxes]` with int32 values in `[0, batch)`.
+The value of `box_ind[i]` specifies the image that the `i`-th box refers to.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A 2-D tensor of shape `[num_boxes, 4]`.
+END
+  }
+  attr {
+    name: "method"
+    description: <<END
+A string specifying the interpolation method. Only 'bilinear' is
+supported for now.
+END
+  }
+  summary: "Computes the gradient of the crop_and_resize op wrt the input boxes tensor."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_CropAndResizeGradImage.pbtxt b/tensorflow/core/api_def/base_api/api_def_CropAndResizeGradImage.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..51fb810007356a33f14b9131dedd08916a6d90fe
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_CropAndResizeGradImage.pbtxt
@@ -0,0 +1,53 @@
+op {
+  graph_op_name: "CropAndResizeGradImage"
+  in_arg {
+    name: "grads"
+    description: <<END
+A 4-D tensor of shape `[num_boxes, crop_height, crop_width, depth]`.
+END
+  }
+  in_arg {
+    name: "boxes"
+    description: <<END
+A 2-D tensor of shape `[num_boxes, 4]`. The `i`-th row of the tensor
+specifies the coordinates of a box in the `box_ind[i]` image and is specified
+in normalized coordinates `[y1, x1, y2, x2]`. A normalized coordinate value of
+`y` is mapped to the image coordinate at `y * (image_height - 1)`, so as the
+`[0, 1]` interval of normalized image height is mapped to
+`[0, image_height - 1] in image height coordinates. We do allow y1 > y2, in
+which case the sampled crop is an up-down flipped version of the original
+image. The width dimension is treated similarly. Normalized coordinates
+outside the `[0, 1]` range are allowed, in which case we use
+`extrapolation_value` to extrapolate the input image values.
+END
+  }
+  in_arg {
+    name: "box_ind"
+    description: <<END
+A 1-D tensor of shape `[num_boxes]` with int32 values in `[0, batch)`.
+The value of `box_ind[i]` specifies the image that the `i`-th box refers to.
+END
+  }
+  in_arg {
+    name: "image_size"
+    description: <<END
+A 1-D tensor with value `[batch, image_height, image_width, depth]`
+containing the original image size. Both `image_height` and `image_width` need
+to be positive.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A 4-D tensor of shape `[batch, image_height, image_width, depth]`.
+END
+  }
+  attr {
+    name: "method"
+    description: <<END
+A string specifying the interpolation method. Only 'bilinear' is
+supported for now.
+END
+  }
+  summary: "Computes the gradient of the crop_and_resize op wrt the input image tensor."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Cross.pbtxt b/tensorflow/core/api_def/base_api/api_def_Cross.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..26c12e459bb81125370eb320de208e4fac66fe73
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Cross.pbtxt
@@ -0,0 +1,27 @@
+op {
+  graph_op_name: "Cross"
+  in_arg {
+    name: "a"
+    description: <<END
+A tensor containing 3-element vectors.
+END
+  }
+  in_arg {
+    name: "b"
+    description: <<END
+Another tensor, of same type and shape as `a`.
+END
+  }
+  out_arg {
+    name: "product"
+    description: <<END
+Pairwise cross product of the vectors in `a` and `b`.
+END
+  }
+  summary: "Compute the pairwise cross product."
+  description: <<END
+`a` and `b` must be the same shape; they can either be simple 3-element vectors,
+or any shape where the innermost dimension is 3. In the latter case, each pair
+of corresponding 3-element vectors is cross-multiplied independently.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Cumprod.pbtxt b/tensorflow/core/api_def/base_api/api_def_Cumprod.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..96e599365aef7a4226c9ec20a6d819fffa91c4e3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Cumprod.pbtxt
@@ -0,0 +1,61 @@
+op {
+  graph_op_name: "Cumprod"
+  in_arg {
+    name: "x"
+    description: <<END
+A `Tensor`. Must be one of the following types: `float32`, `float64`,
+`int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,
+`complex128`, `qint8`, `quint8`, `qint32`, `half`.
+END
+  }
+  in_arg {
+    name: "axis"
+    description: <<END
+A `Tensor` of type `int32` (default: 0). Must be in the range
+`[-rank(x), rank(x))`.
+END
+  }
+  attr {
+    name: "exclusive"
+    description: <<END
+If `True`, perform exclusive cumprod.
+END
+  }
+  attr {
+    name: "reverse"
+    description: <<END
+A `bool` (default: False).
+END
+  }
+  summary: "Compute the cumulative product of the tensor `x` along `axis`."
+  description: <<END
+By default, this op performs an inclusive cumprod, which means that the first
+element of the input is identical to the first element of the output:
+
+```python
+tf.cumprod([a, b, c])  # => [a, a * b, a * b * c]
+```
+
+By setting the `exclusive` kwarg to `True`, an exclusive cumprod is
+performed instead:
+
+```python
+tf.cumprod([a, b, c], exclusive=True)  # => [1, a, a * b]
+```
+
+By setting the `reverse` kwarg to `True`, the cumprod is performed in the
+opposite direction:
+
+```python
+tf.cumprod([a, b, c], reverse=True)  # => [a * b * c, b * c, c]
+```
+
+This is more efficient than using separate `tf.reverse` ops.
+
+The `reverse` and `exclusive` kwargs can also be combined:
+
+```python
+tf.cumprod([a, b, c], exclusive=True, reverse=True)  # => [b * c, c, 1]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Cumsum.pbtxt b/tensorflow/core/api_def/base_api/api_def_Cumsum.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6267f0dfa22b905b7dbc4b6b7b76fa410ee61a68
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Cumsum.pbtxt
@@ -0,0 +1,61 @@
+op {
+  graph_op_name: "Cumsum"
+  in_arg {
+    name: "x"
+    description: <<END
+A `Tensor`. Must be one of the following types: `float32`, `float64`,
+`int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,
+`complex128`, `qint8`, `quint8`, `qint32`, `half`.
+END
+  }
+  in_arg {
+    name: "axis"
+    description: <<END
+A `Tensor` of type `int32` (default: 0). Must be in the range
+`[-rank(x), rank(x))`.
+END
+  }
+  attr {
+    name: "exclusive"
+    description: <<END
+If `True`, perform exclusive cumsum.
+END
+  }
+  attr {
+    name: "reverse"
+    description: <<END
+A `bool` (default: False).
+END
+  }
+  summary: "Compute the cumulative sum of the tensor `x` along `axis`."
+  description: <<END
+By default, this op performs an inclusive cumsum, which means that the first
+element of the input is identical to the first element of the output:
+
+```python
+tf.cumsum([a, b, c])  # => [a, a + b, a + b + c]
+```
+
+By setting the `exclusive` kwarg to `True`, an exclusive cumsum is
+performed instead:
+
+```python
+tf.cumsum([a, b, c], exclusive=True)  # => [0, a, a + b]
+```
+
+By setting the `reverse` kwarg to `True`, the cumsum is performed in the
+opposite direction:
+
+```python
+tf.cumsum([a, b, c], reverse=True)  # => [a + b + c, b + c, c]
+```
+
+This is more efficient than using separate `tf.reverse` ops.
+
+The `reverse` and `exclusive` kwargs can also be combined:
+
+```python
+tf.cumsum([a, b, c], exclusive=True, reverse=True)  # => [b + c, c, 0]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_D.pbtxt b/tensorflow/core/api_def/base_api/api_def_D.pbtxt
deleted file mode 100644
index ff8a7223c7223f5c4b72ffc7154b7fc77d8eeb06..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_D.pbtxt
+++ /dev/null
@@ -1,790 +0,0 @@
-op {
-  graph_op_name: "DebugGradientIdentity"
-  endpoint {
-    name: "DebugGradientIdentity"
-  }
-  summary: "Identity op for gradient debugging."
-  description: <<END
-This op is hidden from public in Python. It is used by TensorFlow Debugger to
-register gradient tensors for gradient debugging.
-END
-}
-op {
-  graph_op_name: "DecodeAndCropJpeg"
-  endpoint {
-    name: "DecodeAndCropJpeg"
-  }
-  summary: "Decode and Crop a JPEG-encoded image to a uint8 tensor."
-  description: <<END
-The attr `channels` indicates the desired number of color channels for the
-decoded image.
-
-Accepted values are:
-
-*   0: Use the number of channels in the JPEG-encoded image.
-*   1: output a grayscale image.
-*   3: output an RGB image.
-
-If needed, the JPEG-encoded image is transformed to match the requested number
-of color channels.
-
-The attr `ratio` allows downscaling the image by an integer factor during
-decoding.  Allowed values are: 1, 2, 4, and 8.  This is much faster than
-downscaling the image later.
-
-
-It is equivalent to a combination of decode and crop, but much faster by only
-decoding partial jpeg image.
-END
-}
-op {
-  graph_op_name: "DecodeBase64"
-  endpoint {
-    name: "DecodeBase64"
-  }
-  summary: "Decode web-safe base64-encoded strings."
-  description: <<END
-Input may or may not have padding at the end. See EncodeBase64 for padding.
-Web-safe means that input must use - and _ instead of + and /.
-END
-}
-op {
-  graph_op_name: "DecodeBmp"
-  endpoint {
-    name: "DecodeBmp"
-  }
-  summary: "Decode the first frame of a BMP-encoded image to a uint8 tensor."
-  description: <<END
-The attr `channels` indicates the desired number of color channels for the
-decoded image.
-
-Accepted values are:
-
-*   0: Use the number of channels in the BMP-encoded image.
-*   3: output an RGB image.
-*   4: output an RGBA image.
-END
-}
-op {
-  graph_op_name: "DecodeCSV"
-  endpoint {
-    name: "DecodeCSV"
-  }
-  summary: "Convert CSV records to tensors. Each column maps to one tensor."
-  description: <<END
-RFC 4180 format is expected for the CSV records.
-(https://tools.ietf.org/html/rfc4180)
-Note that we allow leading and trailing spaces with int or float field.
-END
-}
-op {
-  graph_op_name: "DecodeGif"
-  endpoint {
-    name: "DecodeGif"
-  }
-  summary: "Decode the first frame of a GIF-encoded image to a uint8 tensor."
-  description: <<END
-GIF with frame or transparency compression are not supported
-convert animated GIF from compressed to uncompressed by:
-
-    convert $src.gif -coalesce $dst.gif
-
-This op also supports decoding JPEGs and PNGs, though it is cleaner to use
-`tf.image.decode_image`.
-END
-}
-op {
-  graph_op_name: "DecodeJSONExample"
-  endpoint {
-    name: "DecodeJSONExample"
-  }
-  summary: "Convert JSON-encoded Example records to binary protocol buffer strings."
-  description: <<END
-This op translates a tensor containing Example records, encoded using
-the [standard JSON
-mapping](https://developers.google.com/protocol-buffers/docs/proto3#json),
-into a tensor containing the same records encoded as binary protocol
-buffers. The resulting tensor can then be fed to any of the other
-Example-parsing ops.
-END
-}
-op {
-  graph_op_name: "DecodeJpeg"
-  endpoint {
-    name: "DecodeJpeg"
-  }
-  summary: "Decode a JPEG-encoded image to a uint8 tensor."
-  description: <<END
-The attr `channels` indicates the desired number of color channels for the
-decoded image.
-
-Accepted values are:
-
-*   0: Use the number of channels in the JPEG-encoded image.
-*   1: output a grayscale image.
-*   3: output an RGB image.
-
-If needed, the JPEG-encoded image is transformed to match the requested number
-of color channels.
-
-The attr `ratio` allows downscaling the image by an integer factor during
-decoding.  Allowed values are: 1, 2, 4, and 8.  This is much faster than
-downscaling the image later.
-
-
-This op also supports decoding PNGs and non-animated GIFs since the interface is
-the same, though it is cleaner to use `tf.image.decode_image`.
-END
-}
-op {
-  graph_op_name: "DecodePng"
-  endpoint {
-    name: "DecodePng"
-  }
-  summary: "Decode a PNG-encoded image to a uint8 or uint16 tensor."
-  description: <<END
-The attr `channels` indicates the desired number of color channels for the
-decoded image.
-
-Accepted values are:
-
-*   0: Use the number of channels in the PNG-encoded image.
-*   1: output a grayscale image.
-*   3: output an RGB image.
-*   4: output an RGBA image.
-
-If needed, the PNG-encoded image is transformed to match the requested number
-of color channels.
-
-This op also supports decoding JPEGs and non-animated GIFs since the interface
-is the same, though it is cleaner to use `tf.image.decode_image`.
-END
-}
-op {
-  graph_op_name: "DecodeRaw"
-  endpoint {
-    name: "DecodeRaw"
-  }
-  summary: "Reinterpret the bytes of a string as a vector of numbers."
-}
-op {
-  graph_op_name: "DecodeWav"
-  endpoint {
-    name: "DecodeWav"
-  }
-  summary: "Decode a 16-bit PCM WAV file to a float tensor."
-  description: <<END
-The -32768 to 32767 signed 16-bit values will be scaled to -1.0 to 1.0 in float.
-
-When desired_channels is set, if the input contains fewer channels than this
-then the last channel will be duplicated to give the requested number, else if
-the input has more channels than requested then the additional channels will be
-ignored.
-
-If desired_samples is set, then the audio will be cropped or padded with zeroes
-to the requested length.
-
-The first output contains a Tensor with the content of the audio samples. The
-lowest dimension will be the number of channels, and the second will be the
-number of samples. For example, a ten-sample-long stereo WAV file should give an
-output shape of [10, 2].
-END
-}
-op {
-  graph_op_name: "DeleteSessionTensor"
-  endpoint {
-    name: "DeleteSessionTensor"
-  }
-  summary: "Delete the tensor specified by its handle in the session."
-}
-op {
-  graph_op_name: "DenseToDenseSetOperation"
-  endpoint {
-    name: "DenseToDenseSetOperation"
-  }
-  summary: "Applies set operation along last dimension of 2 `Tensor` inputs."
-  description: <<END
-See SetOperationOp::SetOperationFromContext for values of `set_operation`.
-
-Output `result` is a `SparseTensor` represented by `result_indices`,
-`result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
-has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
-dimension contains the result of `set_operation` applied to the corresponding
-`[0...n-1]` dimension of `set`.
-END
-}
-op {
-  graph_op_name: "DenseToSparseBatchDataset"
-  endpoint {
-    name: "DenseToSparseBatchDataset"
-  }
-  summary: "Creates a dataset that yields a SparseTensor for each element of the input."
-}
-op {
-  graph_op_name: "DenseToSparseSetOperation"
-  endpoint {
-    name: "DenseToSparseSetOperation"
-  }
-  summary: "Applies set operation along last dimension of `Tensor` and `SparseTensor`."
-  description: <<END
-See SetOperationOp::SetOperationFromContext for values of `set_operation`.
-
-Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`,
-and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same
-as `set1`. Dimension `n` contains values in a set, duplicates are allowed but
-ignored.
-
-If `validate_indices` is `True`, this op validates the order and range of `set2`
-indices.
-
-Output `result` is a `SparseTensor` represented by `result_indices`,
-`result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
-has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
-dimension contains the result of `set_operation` applied to the corresponding
-`[0...n-1]` dimension of `set`.
-END
-}
-op {
-  graph_op_name: "DepthToSpace"
-  endpoint {
-    name: "DepthToSpace"
-  }
-  summary: "DepthToSpace for tensors of type T."
-  description: <<END
-Rearranges data from depth into blocks of spatial data.
-This is the reverse transformation of SpaceToDepth. More specifically,
-this op outputs a copy of the input tensor where values from the `depth`
-dimension are moved in spatial blocks to the `height` and `width` dimensions.
-The attr `block_size` indicates the input block size and how the data is moved.
-
-  * Chunks of data of size `block_size * block_size` from depth are rearranged
-    into non-overlapping blocks of size `block_size x block_size`
-  * The width the output tensor is `input_depth * block_size`, whereas the
-    height is `input_height * block_size`.
-  * The Y, X coordinates within each block of the output image are determined
-    by the high order component of the input channel index.
-  * The depth of the input tensor must be divisible by
-    `block_size * block_size`.
-
-The `data_format` attr specifies the layout of the input and output tensors
-with the following options:
-  "NHWC": `[ batch, height, width, channels ]`
-  "NCHW": `[ batch, channels, height, width ]`
-  "NCHW_VECT_C":
-      `qint8 [ batch, channels / 4, height, width, channels % 4 ]`
-
-It is useful to consider the operation as transforming a 6-D Tensor.
-e.g. for data_format = NHWC,
-     Each element in the input tensor can be specified via 6 coordinates,
-     ordered by decreasing memory layout significance as:
-     n,iY,iX,bY,bX,oC  (where n=batch index, iX, iY means X or Y coordinates
-                        within the input image, bX, bY means coordinates
-                        within the output block, oC means output channels).
-     The output would be the input transposed to the following layout:
-     n,iY,bY,iX,bX,oC
-
-This operation is useful for resizing the activations between convolutions
-(but keeping all data), e.g. instead of pooling. It is also useful for training
-purely convolutional models.
-
-For example, given an input of shape `[1, 1, 1, 4]`, data_format = "NHWC" and
-block_size = 2:
-
-```
-x = [[[[1, 2, 3, 4]]]]
-
-```
-
-This operation will output a tensor of shape `[1, 2, 2, 1]`:
-
-```
-   [[[[1], [2]],
-     [[3], [4]]]]
-```
-
-Here, the input has a batch of 1 and each batch element has shape `[1, 1, 4]`,
-the corresponding output will have 2x2 elements and will have a depth of
-1 channel (1 = `4 / (block_size * block_size)`).
-The output element shape is `[2, 2, 1]`.
-
-For an input tensor with larger depth, here of shape `[1, 1, 1, 12]`, e.g.
-
-```
-x = [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
-```
-
-This operation, for block size of 2, will return the following tensor of shape
-`[1, 2, 2, 3]`
-
-```
-   [[[[1, 2, 3], [4, 5, 6]],
-     [[7, 8, 9], [10, 11, 12]]]]
-
-```
-
-Similarly, for the following input of shape `[1 2 2 4]`, and a block size of 2:
-
-```
-x =  [[[[1, 2, 3, 4],
-       [5, 6, 7, 8]],
-      [[9, 10, 11, 12],
-       [13, 14, 15, 16]]]]
-```
-
-the operator will return the following tensor of shape `[1 4 4 1]`:
-
-```
-x = [[[ [1],   [2],  [5],  [6]],
-      [ [3],   [4],  [7],  [8]],
-      [ [9],  [10], [13],  [14]],
-      [ [11], [12], [15],  [16]]]]
-
-```
-END
-}
-op {
-  graph_op_name: "DepthwiseConv2dNative"
-  endpoint {
-    name: "DepthwiseConv2dNative"
-  }
-  summary: "Computes a 2-D depthwise convolution given 4-D `input` and `filter` tensors."
-  description: <<END
-Given an input tensor of shape `[batch, in_height, in_width, in_channels]`
-and a filter / kernel tensor of shape
-`[filter_height, filter_width, in_channels, channel_multiplier]`, containing
-`in_channels` convolutional filters of depth 1, `depthwise_conv2d` applies
-a different filter to each input channel (expanding from 1 channel to
-`channel_multiplier` channels for each), then concatenates the results
-together. Thus, the output has `in_channels * channel_multiplier` channels.
-
-```
-for k in 0..in_channels-1
-  for q in 0..channel_multiplier-1
-    output[b, i, j, k * channel_multiplier + q] =
-      sum_{di, dj} input[b, strides[1] * i + di, strides[2] * j + dj, k] *
-                        filter[di, dj, k, q]
-```
-
-Must have `strides[0] = strides[3] = 1`.  For the most common case of the same
-horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
-END
-}
-op {
-  graph_op_name: "DepthwiseConv2dNativeBackpropFilter"
-  endpoint {
-    name: "DepthwiseConv2dNativeBackpropFilter"
-  }
-  summary: "Computes the gradients of depthwise convolution with respect to the filter."
-}
-op {
-  graph_op_name: "DepthwiseConv2dNativeBackpropInput"
-  endpoint {
-    name: "DepthwiseConv2dNativeBackpropInput"
-  }
-  summary: "Computes the gradients of depthwise convolution with respect to the input."
-}
-op {
-  graph_op_name: "Dequantize"
-  endpoint {
-    name: "Dequantize"
-  }
-  summary: "Dequantize the \'input\' tensor into a float Tensor."
-  description: <<END
-[min_range, max_range] are scalar floats that specify the range for
-the 'input' data. The 'mode' attribute controls exactly which calculations are
-used to convert the float values to their quantized equivalents.
-
-In 'MIN_COMBINED' mode, each value of the tensor will undergo the following:
-
-```
-if T == qint8, in[i] += (range(T) + 1)/ 2.0
-out[i] = min_range + (in[i]* (max_range - min_range) / range(T))
-```
-here `range(T) = numeric_limits<T>::max() - numeric_limits<T>::min()`
-
-*MIN_COMBINED Mode Example*
-
-If the input comes from a QuantizedRelu6, the output type is
-quint8 (range of 0-255) but the possible range of QuantizedRelu6 is
-0-6.  The min_range and max_range values are therefore 0.0 and 6.0.
-Dequantize on quint8 will take each value, cast to float, and multiply
-by 6 / 255.
-Note that if quantizedtype is qint8, the operation will additionally add
-each value by 128 prior to casting.
-
-If the mode is 'MIN_FIRST', then this approach is used:
-
-```c++
-number_of_steps = 1 << (# of bits in T)
-range_adjust = number_of_steps / (number_of_steps - 1)
-range = (range_max - range_min) * range_adjust
-range_scale = range / number_of_steps
-const double offset_input = static_cast<double>(input) - lowest_quantized;
-result = range_min + ((input - numeric_limits<T>::min()) * range_scale)
-```
-
-*SCALED mode Example*
-
-`SCALED` mode matches the quantization approach used in
-`QuantizeAndDequantize{V2|V3}`.
-
-If the mode is `SCALED`, we do not use the full range of the output type,
-choosing to elide the lowest possible value for symmetry (e.g., output range is
--127 to 127, not -128 to 127 for signed 8 bit quantization), so that 0.0 maps to
-0.
-
-We first find the range of values in our tensor. The
-range we use is always centered on 0, so we find m such that
-```c++
-  m = max(abs(input_min), abs(input_max))
-```
-
-Our input tensor range is then `[-m, m]`.
-
-Next, we choose our fixed-point quantization buckets, `[min_fixed, max_fixed]`.
-If T is signed, this is
-```
-  num_bits = sizeof(T) * 8
-  [min_fixed, max_fixed] =
-      [-(1 << (num_bits - 1) - 1), (1 << (num_bits - 1)) - 1]
-```
-
-Otherwise, if T is unsigned, the fixed-point range is
-```
-  [min_fixed, max_fixed] = [0, (1 << num_bits) - 1]
-```
-
-From this we compute our scaling factor, s:
-```c++
-  s = (2 * m) / (max_fixed - min_fixed)
-```
-
-Now we can dequantize the elements of our tensor:
-```c++
-result = input * s
-```
-END
-}
-op {
-  graph_op_name: "DeserializeManySparse"
-  endpoint {
-    name: "DeserializeManySparse"
-  }
-  summary: "Deserialize and concatenate `SparseTensors` from a serialized minibatch."
-  description: <<END
-The input `serialized_sparse` must be a string matrix of shape `[N x 3]` where
-`N` is the minibatch size and the rows correspond to packed outputs of
-`SerializeSparse`.  The ranks of the original `SparseTensor` objects
-must all match.  When the final `SparseTensor` is created, it has rank one
-higher than the ranks of the incoming `SparseTensor` objects
-(they have been concatenated along a new row dimension).
-
-The output `SparseTensor` object's shape values for all dimensions but the
-first are the max across the input `SparseTensor` objects' shape values
-for the corresponding dimensions.  Its first shape value is `N`, the minibatch
-size.
-
-The input `SparseTensor` objects' indices are assumed ordered in
-standard lexicographic order.  If this is not the case, after this
-step run `SparseReorder` to restore index ordering.
-
-For example, if the serialized input is a `[2 x 3]` matrix representing two
-original `SparseTensor` objects:
-
-    index = [ 0]
-            [10]
-            [20]
-    values = [1, 2, 3]
-    shape = [50]
-
-and
-
-    index = [ 2]
-            [10]
-    values = [4, 5]
-    shape = [30]
-
-then the final deserialized `SparseTensor` will be:
-
-    index = [0  0]
-            [0 10]
-            [0 20]
-            [1  2]
-            [1 10]
-    values = [1, 2, 3, 4, 5]
-    shape = [2 50]
-END
-}
-op {
-  graph_op_name: "DestroyTemporaryVariable"
-  endpoint {
-    name: "DestroyTemporaryVariable"
-  }
-  summary: "Destroys the temporary variable and returns its final value."
-  description: <<END
-Sets output to the value of the Tensor pointed to by 'ref', then destroys
-the temporary variable called 'var_name'.
-All other uses of 'ref' *must* have executed before this op.
-This is typically achieved by chaining the ref through each assign op, or by
-using control dependencies.
-
-Outputs the final value of the tensor pointed to by 'ref'.
-END
-}
-op {
-  graph_op_name: "Diag"
-  endpoint {
-    name: "Diag"
-  }
-  summary: "Returns a diagonal tensor with a given diagonal values."
-  description: <<END
-Given a `diagonal`, this operation returns a tensor with the `diagonal` and
-everything else padded with zeros. The diagonal is computed as follows:
-
-Assume `diagonal` has dimensions [D1,..., Dk], then the output is a tensor of
-rank 2k with dimensions [D1,..., Dk, D1,..., Dk] where:
-
-`output[i1,..., ik, i1,..., ik] = diagonal[i1, ..., ik]` and 0 everywhere else.
-
-For example:
-
-```
-# 'diagonal' is [1, 2, 3, 4]
-tf.diag(diagonal) ==> [[1, 0, 0, 0]
-                       [0, 2, 0, 0]
-                       [0, 0, 3, 0]
-                       [0, 0, 0, 4]]
-```
-END
-}
-op {
-  graph_op_name: "DiagPart"
-  endpoint {
-    name: "DiagPart"
-  }
-  summary: "Returns the diagonal part of the tensor."
-  description: <<END
-This operation returns a tensor with the `diagonal` part
-of the `input`. The `diagonal` part is computed as follows:
-
-Assume `input` has dimensions `[D1,..., Dk, D1,..., Dk]`, then the output is a
-tensor of rank `k` with dimensions `[D1,..., Dk]` where:
-
-`diagonal[i1,..., ik] = input[i1, ..., ik, i1,..., ik]`.
-
-For example:
-
-```
-# 'input' is [[1, 0, 0, 0]
-              [0, 2, 0, 0]
-              [0, 0, 3, 0]
-              [0, 0, 0, 4]]
-
-tf.diag_part(input) ==> [1, 2, 3, 4]
-```
-END
-}
-op {
-  graph_op_name: "Digamma"
-  endpoint {
-    name: "Digamma"
-  }
-  summary: "Computes Psi, the derivative of Lgamma (the log of the absolute value of"
-  description: <<END
-`Gamma(x)`), element-wise.
-END
-}
-op {
-  graph_op_name: "Dilation2D"
-  endpoint {
-    name: "Dilation2D"
-  }
-  summary: "Computes the grayscale dilation of 4-D `input` and 3-D `filter` tensors."
-  description: <<END
-The `input` tensor has shape `[batch, in_height, in_width, depth]` and the
-`filter` tensor has shape `[filter_height, filter_width, depth]`, i.e., each
-input channel is processed independently of the others with its own structuring
-function. The `output` tensor has shape
-`[batch, out_height, out_width, depth]`. The spatial dimensions of the output
-tensor depend on the `padding` algorithm. We currently only support the default
-"NHWC" `data_format`.
-
-In detail, the grayscale morphological 2-D dilation is the max-sum correlation
-(for consistency with `conv2d`, we use unmirrored filters):
-
-    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]
-
-Max-pooling is a special case when the filter has size equal to the pooling
-kernel size and contains all zeros.
-
-Note on duality: The dilation of `input` by the `filter` is equal to the
-negation of the erosion of `-input` by the reflected `filter`.
-END
-}
-op {
-  graph_op_name: "Dilation2DBackpropFilter"
-  endpoint {
-    name: "Dilation2DBackpropFilter"
-  }
-  summary: "Computes the gradient of morphological 2-D dilation with respect to the filter."
-}
-op {
-  graph_op_name: "Dilation2DBackpropInput"
-  endpoint {
-    name: "Dilation2DBackpropInput"
-  }
-  summary: "Computes the gradient of morphological 2-D dilation with respect to the input."
-}
-op {
-  graph_op_name: "Div"
-  endpoint {
-    name: "Div"
-  }
-  summary: "Returns x / y element-wise."
-  description: <<END
-*NOTE*: `Div` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "DrawBoundingBoxes"
-  endpoint {
-    name: "DrawBoundingBoxes"
-  }
-  summary: "Draw bounding boxes on a batch of images."
-  description: <<END
-Outputs a copy of `images` but draws on top of the pixels zero or more bounding
-boxes specified by the locations in `boxes`. The coordinates of the each
-bounding box in `boxes` are encoded as `[y_min, x_min, y_max, x_max]`. The
-bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
-height of the underlying image.
-
-For example, if an image is 100 x 200 pixels (height x width) and the bounding
-box is `[0.1, 0.2, 0.5, 0.9]`, the upper-left and bottom-right coordinates of
-the bounding box will be `(40, 10)` to `(100, 50)` (in (x,y) coordinates).
-
-Parts of the bounding box may fall outside the image.
-END
-}
-op {
-  graph_op_name: "DynamicPartition"
-  endpoint {
-    name: "DynamicPartition"
-  }
-  summary: "Partitions `data` into `num_partitions` tensors using indices from `partitions`."
-  description: <<END
-For each index tuple `js` of size `partitions.ndim`, the slice `data[js, ...]`
-becomes part of `outputs[partitions[js]]`.  The slices with `partitions[js] = i`
-are placed in `outputs[i]` in lexicographic order of `js`, and the first
-dimension of `outputs[i]` is the number of entries in `partitions` equal to `i`.
-In detail,
-
-```python
-    outputs[i].shape = [sum(partitions == i)] + data.shape[partitions.ndim:]
-
-    outputs[i] = pack([data[js, ...] for js if partitions[js] == i])
-```
-
-`data.shape` must start with `partitions.shape`.
-
-For example:
-
-```python
-    # Scalar partitions.
-    partitions = 1
-    num_partitions = 2
-    data = [10, 20]
-    outputs[0] = []  # Empty with shape [0, 2]
-    outputs[1] = [[10, 20]]
-
-    # Vector partitions.
-    partitions = [0, 0, 1, 1, 0]
-    num_partitions = 2
-    data = [10, 20, 30, 40, 50]
-    outputs[0] = [10, 20, 50]
-    outputs[1] = [30, 40]
-```
-
-See `dynamic_stitch` for an example on how to merge partitions back.
-
-<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-<img style="width:100%" src="https://www.tensorflow.org/images/DynamicPartition.png" alt>
-</div>
-END
-}
-op {
-  graph_op_name: "DynamicStitch"
-  endpoint {
-    name: "DynamicStitch"
-  }
-  summary: "Interleave the values from the `data` tensors into a single tensor."
-  description: <<END
-Builds a merged tensor such that
-
-```python
-    merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]
-```
-
-For example, if each `indices[m]` is scalar or vector, we have
-
-```python
-    # Scalar indices:
-    merged[indices[m], ...] = data[m][...]
-
-    # Vector indices:
-    merged[indices[m][i], ...] = data[m][i, ...]
-```
-
-Each `data[i].shape` must start with the corresponding `indices[i].shape`,
-and the rest of `data[i].shape` must be constant w.r.t. `i`.  That is, we
-must have `data[i].shape = indices[i].shape + constant`.  In terms of this
-`constant`, the output shape is
-
-    merged.shape = [max(indices)] + constant
-
-Values are merged in order, so if an index appears in both `indices[m][i]` and
-`indices[n][j]` for `(m,i) < (n,j)` the slice `data[n][j]` will appear in the
-merged result. If you do not need this guarantee, ParallelDynamicStitch might
-perform better on some devices.
-
-For example:
-
-```python
-    indices[0] = 6
-    indices[1] = [4, 1]
-    indices[2] = [[5, 2], [0, 3]]
-    data[0] = [61, 62]
-    data[1] = [[41, 42], [11, 12]]
-    data[2] = [[[51, 52], [21, 22]], [[1, 2], [31, 32]]]
-    merged = [[1, 2], [11, 12], [21, 22], [31, 32], [41, 42],
-              [51, 52], [61, 62]]
-```
-
-This method can be used to merge partitions created by `dynamic_partition`
-as illustrated on the following example:
-
-```python
-    # Apply function (increments x_i) on elements for which a certain condition
-    # apply (x_i != -1 in this example).
-    x=tf.constant([0.1, -1., 5.2, 4.3, -1., 7.4])
-    condition_mask=tf.not_equal(x,tf.constant(-1.))
-    partitioned_data = tf.dynamic_partition(
-        x, tf.cast(condition_mask, tf.int32) , 2)
-    partitioned_data[1] = partitioned_data[1] + 1.0
-    condition_indices = tf.dynamic_partition(
-        tf.range(tf.shape(x)[0]), tf.cast(condition_mask, tf.int32) , 2)
-    x = tf.dynamic_stitch(condition_indices, partitioned_data)
-    # Here x=[1.1, -1., 6.2, 5.3, -1, 8.4], the -1. values remain
-    # unchanged.
-```
-
-<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-<img style="width:100%" src="https://www.tensorflow.org/images/DynamicStitch.png" alt>
-</div>
-END
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_DatasetToSingleElement.pbtxt b/tensorflow/core/api_def/base_api/api_def_DatasetToSingleElement.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2b9dffd883250fd5631444252e7b236116e2e822
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DatasetToSingleElement.pbtxt
@@ -0,0 +1,16 @@
+op {
+  graph_op_name: "DatasetToSingleElement"
+  in_arg {
+    name: "dataset"
+    description: <<END
+A handle to a dataset that contains a single element.
+END
+  }
+  out_arg {
+    name: "components"
+    description: <<END
+The components of the single element of `input`.
+END
+  }
+  summary: "Outputs the single element from the given dataset."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DebugGradientIdentity.pbtxt b/tensorflow/core/api_def/base_api/api_def_DebugGradientIdentity.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..38fd6877e9d26e7ab86a4e7f95352a4a39efb7c2
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DebugGradientIdentity.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "DebugGradientIdentity"
+  summary: "Identity op for gradient debugging."
+  description: <<END
+This op is hidden from public in Python. It is used by TensorFlow Debugger to
+register gradient tensors for gradient debugging.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DecodeAndCropJpeg.pbtxt b/tensorflow/core/api_def/base_api/api_def_DecodeAndCropJpeg.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..28318274f3897e152fc7320778fd3e8dbbf15ebc
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DecodeAndCropJpeg.pbtxt
@@ -0,0 +1,86 @@
+op {
+  graph_op_name: "DecodeAndCropJpeg"
+  in_arg {
+    name: "contents"
+    description: <<END
+0-D.  The JPEG-encoded image.
+END
+  }
+  in_arg {
+    name: "crop_window"
+    description: <<END
+1-D.  The crop window: [crop_y, crop_x, crop_height, crop_width].
+END
+  }
+  out_arg {
+    name: "image"
+    description: <<END
+3-D with shape `[height, width, channels]`..
+END
+  }
+  attr {
+    name: "channels"
+    description: <<END
+Number of color channels for the decoded image.
+END
+  }
+  attr {
+    name: "ratio"
+    description: <<END
+Downscaling ratio.
+END
+  }
+  attr {
+    name: "fancy_upscaling"
+    description: <<END
+If true use a slower but nicer upscaling of the
+chroma planes (yuv420/422 only).
+END
+  }
+  attr {
+    name: "try_recover_truncated"
+    description: <<END
+If true try to recover an image from truncated input.
+END
+  }
+  attr {
+    name: "acceptable_fraction"
+    description: <<END
+The minimum required fraction of lines before a truncated
+input is accepted.
+END
+  }
+  attr {
+    name: "dct_method"
+    description: <<END
+string specifying a hint about the algorithm used for
+decompression.  Defaults to "" which maps to a system-specific
+default.  Currently valid values are ["INTEGER_FAST",
+"INTEGER_ACCURATE"].  The hint may be ignored (e.g., the internal
+jpeg library changes to a version that does not have that specific
+option.)
+END
+  }
+  summary: "Decode and Crop a JPEG-encoded image to a uint8 tensor."
+  description: <<END
+The attr `channels` indicates the desired number of color channels for the
+decoded image.
+
+Accepted values are:
+
+*   0: Use the number of channels in the JPEG-encoded image.
+*   1: output a grayscale image.
+*   3: output an RGB image.
+
+If needed, the JPEG-encoded image is transformed to match the requested number
+of color channels.
+
+The attr `ratio` allows downscaling the image by an integer factor during
+decoding.  Allowed values are: 1, 2, 4, and 8.  This is much faster than
+downscaling the image later.
+
+
+It is equivalent to a combination of decode and crop, but much faster by only
+decoding partial jpeg image.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DecodeBase64.pbtxt b/tensorflow/core/api_def/base_api/api_def_DecodeBase64.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6bae3a62d7dfdbc71ececdd6fd3bba0f059a7498
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DecodeBase64.pbtxt
@@ -0,0 +1,20 @@
+op {
+  graph_op_name: "DecodeBase64"
+  in_arg {
+    name: "input"
+    description: <<END
+Base64 strings to decode.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Decoded strings.
+END
+  }
+  summary: "Decode web-safe base64-encoded strings."
+  description: <<END
+Input may or may not have padding at the end. See EncodeBase64 for padding.
+Web-safe means that input must use - and _ instead of + and /.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DecodeBmp.pbtxt b/tensorflow/core/api_def/base_api/api_def_DecodeBmp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3c6918e6a0fc3e8fd7fe40ad6d1f19302b7fe650
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DecodeBmp.pbtxt
@@ -0,0 +1,26 @@
+op {
+  graph_op_name: "DecodeBmp"
+  in_arg {
+    name: "contents"
+    description: <<END
+0-D.  The BMP-encoded image.
+END
+  }
+  out_arg {
+    name: "image"
+    description: <<END
+3-D with shape `[height, width, channels]`. RGB order
+END
+  }
+  summary: "Decode the first frame of a BMP-encoded image to a uint8 tensor."
+  description: <<END
+The attr `channels` indicates the desired number of color channels for the
+decoded image.
+
+Accepted values are:
+
+*   0: Use the number of channels in the BMP-encoded image.
+*   3: output an RGB image.
+*   4: output an RGBA image.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DecodeCSV.pbtxt b/tensorflow/core/api_def/base_api/api_def_DecodeCSV.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e39213cbc77a21788d72cf60349e2a3798a93596
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DecodeCSV.pbtxt
@@ -0,0 +1,49 @@
+op {
+  graph_op_name: "DecodeCSV"
+  in_arg {
+    name: "records"
+    description: <<END
+Each string is a record/row in the csv and all records should have
+the same format.
+END
+  }
+  in_arg {
+    name: "record_defaults"
+    description: <<END
+One tensor per column of the input record, with either a
+scalar default value for that column or empty if the column is required.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Each tensor will have the same shape as records.
+END
+  }
+  attr {
+    name: "field_delim"
+    description: <<END
+char delimiter to separate fields in a record.
+END
+  }
+  attr {
+    name: "use_quote_delim"
+    description: <<END
+If false, treats double quotation marks as regular
+characters inside of the string fields (ignoring RFC 4180, Section 2,
+Bullet 5).
+END
+  }
+  attr {
+    name: "na_value"
+    description: <<END
+Additional string to recognize as NA/NaN.
+END
+  }
+  summary: "Convert CSV records to tensors. Each column maps to one tensor."
+  description: <<END
+RFC 4180 format is expected for the CSV records.
+(https://tools.ietf.org/html/rfc4180)
+Note that we allow leading and trailing spaces with int or float field.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DecodeGif.pbtxt b/tensorflow/core/api_def/base_api/api_def_DecodeGif.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a90b7341555cb7a306ec6f58d727da0707503f52
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DecodeGif.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "DecodeGif"
+  in_arg {
+    name: "contents"
+    description: <<END
+0-D.  The GIF-encoded image.
+END
+  }
+  out_arg {
+    name: "image"
+    description: <<END
+4-D with shape `[num_frames, height, width, 3]`. RGB order
+END
+  }
+  summary: "Decode the first frame of a GIF-encoded image to a uint8 tensor."
+  description: <<END
+GIF with frame or transparency compression are not supported
+convert animated GIF from compressed to uncompressed by:
+
+    convert $src.gif -coalesce $dst.gif
+
+This op also supports decoding JPEGs and PNGs, though it is cleaner to use
+`tf.image.decode_image`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DecodeJSONExample.pbtxt b/tensorflow/core/api_def/base_api/api_def_DecodeJSONExample.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cdf1c5f37ddcaa0e5aecfab2cb681298072961eb
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DecodeJSONExample.pbtxt
@@ -0,0 +1,26 @@
+op {
+  graph_op_name: "DecodeJSONExample"
+  in_arg {
+    name: "json_examples"
+    description: <<END
+Each string is a JSON object serialized according to the JSON
+mapping of the Example proto.
+END
+  }
+  out_arg {
+    name: "binary_examples"
+    description: <<END
+Each string is a binary Example protocol buffer corresponding
+to the respective element of `json_examples`.
+END
+  }
+  summary: "Convert JSON-encoded Example records to binary protocol buffer strings."
+  description: <<END
+This op translates a tensor containing Example records, encoded using
+the [standard JSON
+mapping](https://developers.google.com/protocol-buffers/docs/proto3#json),
+into a tensor containing the same records encoded as binary protocol
+buffers. The resulting tensor can then be fed to any of the other
+Example-parsing ops.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DecodeJpeg.pbtxt b/tensorflow/core/api_def/base_api/api_def_DecodeJpeg.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b9521370d35050c37282adda774ac58f5e14effa
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DecodeJpeg.pbtxt
@@ -0,0 +1,80 @@
+op {
+  graph_op_name: "DecodeJpeg"
+  in_arg {
+    name: "contents"
+    description: <<END
+0-D.  The JPEG-encoded image.
+END
+  }
+  out_arg {
+    name: "image"
+    description: <<END
+3-D with shape `[height, width, channels]`..
+END
+  }
+  attr {
+    name: "channels"
+    description: <<END
+Number of color channels for the decoded image.
+END
+  }
+  attr {
+    name: "ratio"
+    description: <<END
+Downscaling ratio.
+END
+  }
+  attr {
+    name: "fancy_upscaling"
+    description: <<END
+If true use a slower but nicer upscaling of the
+chroma planes (yuv420/422 only).
+END
+  }
+  attr {
+    name: "try_recover_truncated"
+    description: <<END
+If true try to recover an image from truncated input.
+END
+  }
+  attr {
+    name: "acceptable_fraction"
+    description: <<END
+The minimum required fraction of lines before a truncated
+input is accepted.
+END
+  }
+  attr {
+    name: "dct_method"
+    description: <<END
+string specifying a hint about the algorithm used for
+decompression.  Defaults to "" which maps to a system-specific
+default.  Currently valid values are ["INTEGER_FAST",
+"INTEGER_ACCURATE"].  The hint may be ignored (e.g., the internal
+jpeg library changes to a version that does not have that specific
+option.)
+END
+  }
+  summary: "Decode a JPEG-encoded image to a uint8 tensor."
+  description: <<END
+The attr `channels` indicates the desired number of color channels for the
+decoded image.
+
+Accepted values are:
+
+*   0: Use the number of channels in the JPEG-encoded image.
+*   1: output a grayscale image.
+*   3: output an RGB image.
+
+If needed, the JPEG-encoded image is transformed to match the requested number
+of color channels.
+
+The attr `ratio` allows downscaling the image by an integer factor during
+decoding.  Allowed values are: 1, 2, 4, and 8.  This is much faster than
+downscaling the image later.
+
+
+This op also supports decoding PNGs and non-animated GIFs since the interface is
+the same, though it is cleaner to use `tf.image.decode_image`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DecodePng.pbtxt b/tensorflow/core/api_def/base_api/api_def_DecodePng.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..63404db800968db5ba34a8a0f9509573b9d9824a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DecodePng.pbtxt
@@ -0,0 +1,39 @@
+op {
+  graph_op_name: "DecodePng"
+  in_arg {
+    name: "contents"
+    description: <<END
+0-D.  The PNG-encoded image.
+END
+  }
+  out_arg {
+    name: "image"
+    description: <<END
+3-D with shape `[height, width, channels]`.
+END
+  }
+  attr {
+    name: "channels"
+    description: <<END
+Number of color channels for the decoded image.
+END
+  }
+  summary: "Decode a PNG-encoded image to a uint8 or uint16 tensor."
+  description: <<END
+The attr `channels` indicates the desired number of color channels for the
+decoded image.
+
+Accepted values are:
+
+*   0: Use the number of channels in the PNG-encoded image.
+*   1: output a grayscale image.
+*   3: output an RGB image.
+*   4: output an RGBA image.
+
+If needed, the PNG-encoded image is transformed to match the requested number
+of color channels.
+
+This op also supports decoding JPEGs and non-animated GIFs since the interface
+is the same, though it is cleaner to use `tf.image.decode_image`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DecodeRaw.pbtxt b/tensorflow/core/api_def/base_api/api_def_DecodeRaw.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..27ca061013ef3c94f17828fb17d1279c0a97ac35
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DecodeRaw.pbtxt
@@ -0,0 +1,26 @@
+op {
+  graph_op_name: "DecodeRaw"
+  in_arg {
+    name: "bytes"
+    description: <<END
+All the elements must have the same length.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A Tensor with one more dimension than the input `bytes`.  The
+added dimension will have size equal to the length of the elements
+of `bytes` divided by the number of bytes to represent `out_type`.
+END
+  }
+  attr {
+    name: "little_endian"
+    description: <<END
+Whether the input `bytes` are in little-endian order.
+Ignored for `out_type` values that are stored in a single byte like
+`uint8`.
+END
+  }
+  summary: "Reinterpret the bytes of a string as a vector of numbers."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DecodeWav.pbtxt b/tensorflow/core/api_def/base_api/api_def_DecodeWav.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9f055e73d3e57f01a57d9f27a995c3acffc8abba
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DecodeWav.pbtxt
@@ -0,0 +1,50 @@
+op {
+  graph_op_name: "DecodeWav"
+  in_arg {
+    name: "contents"
+    description: <<END
+The WAV-encoded audio, usually from a file.
+END
+  }
+  out_arg {
+    name: "audio"
+    description: <<END
+2-D with shape `[length, channels]`.
+END
+  }
+  out_arg {
+    name: "sample_rate"
+    description: <<END
+Scalar holding the sample rate found in the WAV header.
+END
+  }
+  attr {
+    name: "desired_channels"
+    description: <<END
+Number of sample channels wanted.
+END
+  }
+  attr {
+    name: "desired_samples"
+    description: <<END
+Length of audio requested.
+END
+  }
+  summary: "Decode a 16-bit PCM WAV file to a float tensor."
+  description: <<END
+The -32768 to 32767 signed 16-bit values will be scaled to -1.0 to 1.0 in float.
+
+When desired_channels is set, if the input contains fewer channels than this
+then the last channel will be duplicated to give the requested number, else if
+the input has more channels than requested then the additional channels will be
+ignored.
+
+If desired_samples is set, then the audio will be cropped or padded with zeroes
+to the requested length.
+
+The first output contains a Tensor with the content of the audio samples. The
+lowest dimension will be the number of channels, and the second will be the
+number of samples. For example, a ten-sample-long stereo WAV file should give an
+output shape of [10, 2].
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DeleteSessionTensor.pbtxt b/tensorflow/core/api_def/base_api/api_def_DeleteSessionTensor.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..16aaa7a802f7b790d8c6fc990869edb2d930c2a9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DeleteSessionTensor.pbtxt
@@ -0,0 +1,10 @@
+op {
+  graph_op_name: "DeleteSessionTensor"
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle for a tensor stored in the session state.
+END
+  }
+  summary: "Delete the tensor specified by its handle in the session."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DenseToDenseSetOperation.pbtxt b/tensorflow/core/api_def/base_api/api_def_DenseToDenseSetOperation.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b8a469de95ff8940b4f3cae30d3c350ac626dcbb
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DenseToDenseSetOperation.pbtxt
@@ -0,0 +1,47 @@
+op {
+  graph_op_name: "DenseToDenseSetOperation"
+  in_arg {
+    name: "set1"
+    description: <<END
+`Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set2`.
+Dimension `n` contains values in a set, duplicates are allowed but ignored.
+END
+  }
+  in_arg {
+    name: "set2"
+    description: <<END
+`Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set1`.
+Dimension `n` contains values in a set, duplicates are allowed but ignored.
+END
+  }
+  out_arg {
+    name: "result_indices"
+    description: <<END
+2D indices of a `SparseTensor`.
+END
+  }
+  out_arg {
+    name: "result_values"
+    description: <<END
+1D values of a `SparseTensor`.
+END
+  }
+  out_arg {
+    name: "result_shape"
+    description: <<END
+1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
+the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
+is the max result set size across all `0...n-1` dimensions.
+END
+  }
+  summary: "Applies set operation along last dimension of 2 `Tensor` inputs."
+  description: <<END
+See SetOperationOp::SetOperationFromContext for values of `set_operation`.
+
+Output `result` is a `SparseTensor` represented by `result_indices`,
+`result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
+has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
+dimension contains the result of `set_operation` applied to the corresponding
+`[0...n-1]` dimension of `set`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DenseToSparseBatchDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_DenseToSparseBatchDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f2f5594c7c16b20ef934539b96bc78d324c1542d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DenseToSparseBatchDataset.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "DenseToSparseBatchDataset"
+  in_arg {
+    name: "input_dataset"
+    description: <<END
+A handle to an input dataset. Must have a single component.
+END
+  }
+  in_arg {
+    name: "batch_size"
+    description: <<END
+A scalar representing the number of elements to accumulate in a
+batch.
+END
+  }
+  in_arg {
+    name: "row_shape"
+    description: <<END
+A vector representing the dense shape of each row in the produced
+SparseTensor. The shape may be partially specified, using `-1` to indicate
+that a particular dimension should use the maximum size of all batch elements.
+END
+  }
+  summary: "Creates a dataset that yields a SparseTensor for each element of the input."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DenseToSparseSetOperation.pbtxt b/tensorflow/core/api_def/base_api/api_def_DenseToSparseSetOperation.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a4b086637346429c541a85567bb9220877a57d24
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DenseToSparseSetOperation.pbtxt
@@ -0,0 +1,70 @@
+op {
+  graph_op_name: "DenseToSparseSetOperation"
+  in_arg {
+    name: "set1"
+    description: <<END
+`Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set2`.
+Dimension `n` contains values in a set, duplicates are allowed but ignored.
+END
+  }
+  in_arg {
+    name: "set2_indices"
+    description: <<END
+2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
+order.
+END
+  }
+  in_arg {
+    name: "set2_values"
+    description: <<END
+1D `Tensor`, values of a `SparseTensor`. Must be in row-major
+order.
+END
+  }
+  in_arg {
+    name: "set2_shape"
+    description: <<END
+1D `Tensor`, shape of a `SparseTensor`. `set2_shape[0...n-1]` must
+be the same as the 1st `n-1` dimensions of `set1`, `result_shape[n]` is the
+max set size across `n-1` dimensions.
+END
+  }
+  out_arg {
+    name: "result_indices"
+    description: <<END
+2D indices of a `SparseTensor`.
+END
+  }
+  out_arg {
+    name: "result_values"
+    description: <<END
+1D values of a `SparseTensor`.
+END
+  }
+  out_arg {
+    name: "result_shape"
+    description: <<END
+1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
+the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
+is the max result set size across all `0...n-1` dimensions.
+END
+  }
+  summary: "Applies set operation along last dimension of `Tensor` and `SparseTensor`."
+  description: <<END
+See SetOperationOp::SetOperationFromContext for values of `set_operation`.
+
+Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`,
+and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same
+as `set1`. Dimension `n` contains values in a set, duplicates are allowed but
+ignored.
+
+If `validate_indices` is `True`, this op validates the order and range of `set2`
+indices.
+
+Output `result` is a `SparseTensor` represented by `result_indices`,
+`result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
+has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
+dimension contains the result of `set_operation` applied to the corresponding
+`[0...n-1]` dimension of `set`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DepthToSpace.pbtxt b/tensorflow/core/api_def/base_api/api_def_DepthToSpace.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e7a18cd6b474d34bcc839f51fd13218c76c61294
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DepthToSpace.pbtxt
@@ -0,0 +1,101 @@
+op {
+  graph_op_name: "DepthToSpace"
+  attr {
+    name: "block_size"
+    description: <<END
+The size of the spatial block, same as in Space2Depth.
+END
+  }
+  summary: "DepthToSpace for tensors of type T."
+  description: <<END
+Rearranges data from depth into blocks of spatial data.
+This is the reverse transformation of SpaceToDepth. More specifically,
+this op outputs a copy of the input tensor where values from the `depth`
+dimension are moved in spatial blocks to the `height` and `width` dimensions.
+The attr `block_size` indicates the input block size and how the data is moved.
+
+  * Chunks of data of size `block_size * block_size` from depth are rearranged
+    into non-overlapping blocks of size `block_size x block_size`
+  * The width the output tensor is `input_depth * block_size`, whereas the
+    height is `input_height * block_size`.
+  * The Y, X coordinates within each block of the output image are determined
+    by the high order component of the input channel index.
+  * The depth of the input tensor must be divisible by
+    `block_size * block_size`.
+
+The `data_format` attr specifies the layout of the input and output tensors
+with the following options:
+  "NHWC": `[ batch, height, width, channels ]`
+  "NCHW": `[ batch, channels, height, width ]`
+  "NCHW_VECT_C":
+      `qint8 [ batch, channels / 4, height, width, channels % 4 ]`
+
+It is useful to consider the operation as transforming a 6-D Tensor.
+e.g. for data_format = NHWC,
+     Each element in the input tensor can be specified via 6 coordinates,
+     ordered by decreasing memory layout significance as:
+     n,iY,iX,bY,bX,oC  (where n=batch index, iX, iY means X or Y coordinates
+                        within the input image, bX, bY means coordinates
+                        within the output block, oC means output channels).
+     The output would be the input transposed to the following layout:
+     n,iY,bY,iX,bX,oC
+
+This operation is useful for resizing the activations between convolutions
+(but keeping all data), e.g. instead of pooling. It is also useful for training
+purely convolutional models.
+
+For example, given an input of shape `[1, 1, 1, 4]`, data_format = "NHWC" and
+block_size = 2:
+
+```
+x = [[[[1, 2, 3, 4]]]]
+
+```
+
+This operation will output a tensor of shape `[1, 2, 2, 1]`:
+
+```
+   [[[[1], [2]],
+     [[3], [4]]]]
+```
+
+Here, the input has a batch of 1 and each batch element has shape `[1, 1, 4]`,
+the corresponding output will have 2x2 elements and will have a depth of
+1 channel (1 = `4 / (block_size * block_size)`).
+The output element shape is `[2, 2, 1]`.
+
+For an input tensor with larger depth, here of shape `[1, 1, 1, 12]`, e.g.
+
+```
+x = [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
+```
+
+This operation, for block size of 2, will return the following tensor of shape
+`[1, 2, 2, 3]`
+
+```
+   [[[[1, 2, 3], [4, 5, 6]],
+     [[7, 8, 9], [10, 11, 12]]]]
+
+```
+
+Similarly, for the following input of shape `[1 2 2 4]`, and a block size of 2:
+
+```
+x =  [[[[1, 2, 3, 4],
+       [5, 6, 7, 8]],
+      [[9, 10, 11, 12],
+       [13, 14, 15, 16]]]]
+```
+
+the operator will return the following tensor of shape `[1 4 4 1]`:
+
+```
+x = [[[ [1],   [2],  [5],  [6]],
+      [ [3],   [4],  [7],  [8]],
+      [ [9],  [10], [13],  [14]],
+      [ [11], [12], [15],  [16]]]]
+
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DepthwiseConv2dNative.pbtxt b/tensorflow/core/api_def/base_api/api_def_DepthwiseConv2dNative.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cc10ebe923870426bc9076ca6c96f0497bce1d51
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DepthwiseConv2dNative.pbtxt
@@ -0,0 +1,47 @@
+op {
+  graph_op_name: "DepthwiseConv2dNative"
+  attr {
+    name: "strides"
+    description: <<END
+1-D of length 4.  The stride of the sliding window for each dimension
+of `input`.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+Specify the data format of the input and output data. With the
+default format "NHWC", the data is stored in the order of:
+    [batch, height, width, channels].
+Alternatively, the format could be "NCHW", the data storage order of:
+    [batch, channels, height, width].
+END
+  }
+  summary: "Computes a 2-D depthwise convolution given 4-D `input` and `filter` tensors."
+  description: <<END
+Given an input tensor of shape `[batch, in_height, in_width, in_channels]`
+and a filter / kernel tensor of shape
+`[filter_height, filter_width, in_channels, channel_multiplier]`, containing
+`in_channels` convolutional filters of depth 1, `depthwise_conv2d` applies
+a different filter to each input channel (expanding from 1 channel to
+`channel_multiplier` channels for each), then concatenates the results
+together. Thus, the output has `in_channels * channel_multiplier` channels.
+
+```
+for k in 0..in_channels-1
+  for q in 0..channel_multiplier-1
+    output[b, i, j, k * channel_multiplier + q] =
+      sum_{di, dj} input[b, strides[1] * i + di, strides[2] * j + dj, k] *
+                        filter[di, dj, k, q]
+```
+
+Must have `strides[0] = strides[3] = 1`.  For the most common case of the same
+horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DepthwiseConv2dNativeBackpropFilter.pbtxt b/tensorflow/core/api_def/base_api/api_def_DepthwiseConv2dNativeBackpropFilter.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9126be2afa9bafb3372cfe38fe43f73239e86c72
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DepthwiseConv2dNativeBackpropFilter.pbtxt
@@ -0,0 +1,60 @@
+op {
+  graph_op_name: "DepthwiseConv2dNativeBackpropFilter"
+  in_arg {
+    name: "input"
+    description: <<END
+4-D with shape based on `data_format`.  For example, if
+`data_format` is 'NHWC' then `input` is a 4-D `[batch, in_height,
+in_width, in_channels]` tensor.
+END
+  }
+  in_arg {
+    name: "filter_sizes"
+    description: <<END
+An integer vector representing the tensor shape of `filter`,
+where `filter` is a 4-D
+`[filter_height, filter_width, in_channels, depthwise_multiplier]` tensor.
+END
+  }
+  in_arg {
+    name: "out_backprop"
+    description: <<END
+4-D with shape  based on `data_format`.
+For example, if `data_format` is 'NHWC' then
+out_backprop shape is `[batch, out_height, out_width, out_channels]`.
+Gradients w.r.t. the output of the convolution.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+4-D with shape
+`[filter_height, filter_width, in_channels, out_channels]`.  Gradient w.r.t.
+the `filter` input of the convolution.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the input
+of the convolution.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+Specify the data format of the input and output data. With the
+default format "NHWC", the data is stored in the order of:
+    [batch, height, width, channels].
+Alternatively, the format could be "NCHW", the data storage order of:
+    [batch, channels, height, width].
+END
+  }
+  summary: "Computes the gradients of depthwise convolution with respect to the filter."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DepthwiseConv2dNativeBackpropInput.pbtxt b/tensorflow/core/api_def/base_api/api_def_DepthwiseConv2dNativeBackpropInput.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f1d16858dbf17e2974f6f1487857b63a40c99b91
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DepthwiseConv2dNativeBackpropInput.pbtxt
@@ -0,0 +1,60 @@
+op {
+  graph_op_name: "DepthwiseConv2dNativeBackpropInput"
+  in_arg {
+    name: "input_sizes"
+    description: <<END
+An integer vector representing the shape of `input`, based
+on `data_format`.  For example, if `data_format` is 'NHWC' then
+ `input` is a 4-D `[batch, height, width, channels]` tensor.
+END
+  }
+  in_arg {
+    name: "filter"
+    description: <<END
+4-D with shape
+`[filter_height, filter_width, in_channels, depthwise_multiplier]`.
+END
+  }
+  in_arg {
+    name: "out_backprop"
+    description: <<END
+4-D with shape  based on `data_format`.
+For example, if `data_format` is 'NHWC' then
+out_backprop shape is `[batch, out_height, out_width, out_channels]`.
+Gradients w.r.t. the output of the convolution.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+4-D with shape according to `data_format`.  For example, if
+`data_format` is 'NHWC', output shape is `[batch, in_height,
+in_width, in_channels]`.  Gradient w.r.t. the input of the
+convolution.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the input
+of the convolution.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+Specify the data format of the input and output data. With the
+default format "NHWC", the data is stored in the order of:
+    [batch, height, width, channels].
+Alternatively, the format could be "NCHW", the data storage order of:
+    [batch, channels, height, width].
+END
+  }
+  summary: "Computes the gradients of depthwise convolution with respect to the input."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Dequantize.pbtxt b/tensorflow/core/api_def/base_api/api_def_Dequantize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..40c00ef58f8d9e6262023d6a3299fa5f6fbd8f2a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Dequantize.pbtxt
@@ -0,0 +1,91 @@
+op {
+  graph_op_name: "Dequantize"
+  in_arg {
+    name: "min_range"
+    description: <<END
+The minimum scalar value possibly produced for the input.
+END
+  }
+  in_arg {
+    name: "max_range"
+    description: <<END
+The maximum scalar value possibly produced for the input.
+END
+  }
+  summary: "Dequantize the \'input\' tensor into a float Tensor."
+  description: <<END
+[min_range, max_range] are scalar floats that specify the range for
+the 'input' data. The 'mode' attribute controls exactly which calculations are
+used to convert the float values to their quantized equivalents.
+
+In 'MIN_COMBINED' mode, each value of the tensor will undergo the following:
+
+```
+if T == qint8, in[i] += (range(T) + 1)/ 2.0
+out[i] = min_range + (in[i]* (max_range - min_range) / range(T))
+```
+here `range(T) = numeric_limits<T>::max() - numeric_limits<T>::min()`
+
+*MIN_COMBINED Mode Example*
+
+If the input comes from a QuantizedRelu6, the output type is
+quint8 (range of 0-255) but the possible range of QuantizedRelu6 is
+0-6.  The min_range and max_range values are therefore 0.0 and 6.0.
+Dequantize on quint8 will take each value, cast to float, and multiply
+by 6 / 255.
+Note that if quantizedtype is qint8, the operation will additionally add
+each value by 128 prior to casting.
+
+If the mode is 'MIN_FIRST', then this approach is used:
+
+```c++
+num_discrete_values = 1 << (# of bits in T)
+range_adjust = num_discrete_values / (num_discrete_values - 1)
+range = (range_max - range_min) * range_adjust
+range_scale = range / num_discrete_values
+const double offset_input = static_cast<double>(input) - lowest_quantized;
+result = range_min + ((input - numeric_limits<T>::min()) * range_scale)
+```
+
+*SCALED mode Example*
+
+`SCALED` mode matches the quantization approach used in
+`QuantizeAndDequantize{V2|V3}`.
+
+If the mode is `SCALED`, we do not use the full range of the output type,
+choosing to elide the lowest possible value for symmetry (e.g., output range is
+-127 to 127, not -128 to 127 for signed 8 bit quantization), so that 0.0 maps to
+0.
+
+We first find the range of values in our tensor. The
+range we use is always centered on 0, so we find m such that
+```c++
+  m = max(abs(input_min), abs(input_max))
+```
+
+Our input tensor range is then `[-m, m]`.
+
+Next, we choose our fixed-point quantization buckets, `[min_fixed, max_fixed]`.
+If T is signed, this is
+```
+  num_bits = sizeof(T) * 8
+  [min_fixed, max_fixed] =
+      [-(1 << (num_bits - 1) - 1), (1 << (num_bits - 1)) - 1]
+```
+
+Otherwise, if T is unsigned, the fixed-point range is
+```
+  [min_fixed, max_fixed] = [0, (1 << num_bits) - 1]
+```
+
+From this we compute our scaling factor, s:
+```c++
+  s = (2 * m) / (max_fixed - min_fixed)
+```
+
+Now we can dequantize the elements of our tensor:
+```c++
+result = input * s
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DeserializeIterator.pbtxt b/tensorflow/core/api_def/base_api/api_def_DeserializeIterator.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..653f6789db1119d464931f2b2eb737a125d29a4f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DeserializeIterator.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "DeserializeIterator"
+  in_arg {
+    name: "resource_handle"
+    description: <<END
+A handle to an iterator resource.
+END
+  }
+  in_arg {
+    name: "serialized"
+    description: <<END
+A variant tensor storing the state of the iterator contained in the
+resource.
+END
+  }
+  summary: "Converts the given variant tensor to an iterator and stores it in the given resource."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DeserializeManySparse.pbtxt b/tensorflow/core/api_def/base_api/api_def_DeserializeManySparse.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b1fb5eae02a35d42eb7f68a6597293beb0ebcaf7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DeserializeManySparse.pbtxt
@@ -0,0 +1,60 @@
+op {
+  graph_op_name: "DeserializeManySparse"
+  in_arg {
+    name: "serialized_sparse"
+    description: <<END
+2-D, The `N` serialized `SparseTensor` objects.
+Must have 3 columns.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The `dtype` of the serialized `SparseTensor` objects.
+END
+  }
+  summary: "Deserialize and concatenate `SparseTensors` from a serialized minibatch."
+  description: <<END
+The input `serialized_sparse` must be a string matrix of shape `[N x 3]` where
+`N` is the minibatch size and the rows correspond to packed outputs of
+`SerializeSparse`.  The ranks of the original `SparseTensor` objects
+must all match.  When the final `SparseTensor` is created, it has rank one
+higher than the ranks of the incoming `SparseTensor` objects
+(they have been concatenated along a new row dimension).
+
+The output `SparseTensor` object's shape values for all dimensions but the
+first are the max across the input `SparseTensor` objects' shape values
+for the corresponding dimensions.  Its first shape value is `N`, the minibatch
+size.
+
+The input `SparseTensor` objects' indices are assumed ordered in
+standard lexicographic order.  If this is not the case, after this
+step run `SparseReorder` to restore index ordering.
+
+For example, if the serialized input is a `[2 x 3]` matrix representing two
+original `SparseTensor` objects:
+
+    index = [ 0]
+            [10]
+            [20]
+    values = [1, 2, 3]
+    shape = [50]
+
+and
+
+    index = [ 2]
+            [10]
+    values = [4, 5]
+    shape = [30]
+
+then the final deserialized `SparseTensor` will be:
+
+    index = [0  0]
+            [0 10]
+            [0 20]
+            [1  2]
+            [1 10]
+    values = [1, 2, 3, 4, 5]
+    shape = [2 50]
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DestroyResourceOp.pbtxt b/tensorflow/core/api_def/base_api/api_def_DestroyResourceOp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..910d25ec825dcbea8d73364ee6b599b6c59c1876
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DestroyResourceOp.pbtxt
@@ -0,0 +1,21 @@
+op {
+  graph_op_name: "DestroyResourceOp"
+  in_arg {
+    name: "resource"
+    description: <<END
+handle to the resource to delete.
+END
+  }
+  attr {
+    name: "ignore_lookup_error"
+    description: <<END
+whether to ignore the error when the resource
+doesn't exist.
+END
+  }
+  summary: "Deletes the resource specified by the handle."
+  description: <<END
+All subsequent operations using the resource will result in a NotFound
+error status.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DestroyTemporaryVariable.pbtxt b/tensorflow/core/api_def/base_api/api_def_DestroyTemporaryVariable.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2ae9a30cb43613ef351b57c56d0b215fa7dd1e6f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DestroyTemporaryVariable.pbtxt
@@ -0,0 +1,26 @@
+op {
+  graph_op_name: "DestroyTemporaryVariable"
+  in_arg {
+    name: "ref"
+    description: <<END
+A reference to the temporary variable tensor.
+END
+  }
+  attr {
+    name: "var_name"
+    description: <<END
+Name of the temporary variable, usually the name of the matching
+'TemporaryVariable' op.
+END
+  }
+  summary: "Destroys the temporary variable and returns its final value."
+  description: <<END
+Sets output to the value of the Tensor pointed to by 'ref', then destroys
+the temporary variable called 'var_name'.
+All other uses of 'ref' *must* have executed before this op.
+This is typically achieved by chaining the ref through each assign op, or by
+using control dependencies.
+
+Outputs the final value of the tensor pointed to by 'ref'.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Diag.pbtxt b/tensorflow/core/api_def/base_api/api_def_Diag.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e69d9077f96502c7fb7e0f012e0b1e5417dab438
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Diag.pbtxt
@@ -0,0 +1,29 @@
+op {
+  graph_op_name: "Diag"
+  in_arg {
+    name: "diagonal"
+    description: <<END
+Rank k tensor where k is at most 1.
+END
+  }
+  summary: "Returns a diagonal tensor with a given diagonal values."
+  description: <<END
+Given a `diagonal`, this operation returns a tensor with the `diagonal` and
+everything else padded with zeros. The diagonal is computed as follows:
+
+Assume `diagonal` has dimensions [D1,..., Dk], then the output is a tensor of
+rank 2k with dimensions [D1,..., Dk, D1,..., Dk] where:
+
+`output[i1,..., ik, i1,..., ik] = diagonal[i1, ..., ik]` and 0 everywhere else.
+
+For example:
+
+```
+# 'diagonal' is [1, 2, 3, 4]
+tf.diag(diagonal) ==> [[1, 0, 0, 0]
+                       [0, 2, 0, 0]
+                       [0, 0, 3, 0]
+                       [0, 0, 0, 4]]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DiagPart.pbtxt b/tensorflow/core/api_def/base_api/api_def_DiagPart.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1af7df95b7ce4071a5634bc9fa089e6e8c703664
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DiagPart.pbtxt
@@ -0,0 +1,36 @@
+op {
+  graph_op_name: "DiagPart"
+  in_arg {
+    name: "input"
+    description: <<END
+Rank k tensor where k is even and not zero.
+END
+  }
+  out_arg {
+    name: "diagonal"
+    description: <<END
+The extracted diagonal.
+END
+  }
+  summary: "Returns the diagonal part of the tensor."
+  description: <<END
+This operation returns a tensor with the `diagonal` part
+of the `input`. The `diagonal` part is computed as follows:
+
+Assume `input` has dimensions `[D1,..., Dk, D1,..., Dk]`, then the output is a
+tensor of rank `k` with dimensions `[D1,..., Dk]` where:
+
+`diagonal[i1,..., ik] = input[i1, ..., ik, i1,..., ik]`.
+
+For example:
+
+```
+# 'input' is [[1, 0, 0, 0]
+              [0, 2, 0, 0]
+              [0, 0, 3, 0]
+              [0, 0, 0, 4]]
+
+tf.diag_part(input) ==> [1, 2, 3, 4]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Digamma.pbtxt b/tensorflow/core/api_def/base_api/api_def_Digamma.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0a8280701ba3c6cd5db21e966eff27f2e7639a6e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Digamma.pbtxt
@@ -0,0 +1,7 @@
+op {
+  graph_op_name: "Digamma"
+  summary: "Computes Psi, the derivative of Lgamma (the log of the absolute value of"
+  description: <<END
+`Gamma(x)`), element-wise.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Dilation2D.pbtxt b/tensorflow/core/api_def/base_api/api_def_Dilation2D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b38f5aa4f9cb9257ac15238115ff1b7165fbc94b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Dilation2D.pbtxt
@@ -0,0 +1,67 @@
+op {
+  graph_op_name: "Dilation2D"
+  in_arg {
+    name: "input"
+    description: <<END
+4-D with shape `[batch, in_height, in_width, depth]`.
+END
+  }
+  in_arg {
+    name: "filter"
+    description: <<END
+3-D with shape `[filter_height, filter_width, depth]`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+4-D with shape `[batch, out_height, out_width, depth]`.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the input
+tensor. Must be: `[1, stride_height, stride_width, 1]`.
+END
+  }
+  attr {
+    name: "rates"
+    description: <<END
+The input stride for atrous morphological dilation. Must be:
+`[1, rate_height, rate_width, 1]`.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  summary: "Computes the grayscale dilation of 4-D `input` and 3-D `filter` tensors."
+  description: <<END
+The `input` tensor has shape `[batch, in_height, in_width, depth]` and the
+`filter` tensor has shape `[filter_height, filter_width, depth]`, i.e., each
+input channel is processed independently of the others with its own structuring
+function. The `output` tensor has shape
+`[batch, out_height, out_width, depth]`. The spatial dimensions of the output
+tensor depend on the `padding` algorithm. We currently only support the default
+"NHWC" `data_format`.
+
+In detail, the grayscale morphological 2-D dilation is the max-sum correlation
+(for consistency with `conv2d`, we use unmirrored filters):
+
+    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]
+
+Max-pooling is a special case when the filter has size equal to the pooling
+kernel size and contains all zeros.
+
+Note on duality: The dilation of `input` by the `filter` is equal to the
+negation of the erosion of `-input` by the reflected `filter`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Dilation2DBackpropFilter.pbtxt b/tensorflow/core/api_def/base_api/api_def_Dilation2DBackpropFilter.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a58f3b48edc8a82ba24ac80c81255afdd30989e0
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Dilation2DBackpropFilter.pbtxt
@@ -0,0 +1,48 @@
+op {
+  graph_op_name: "Dilation2DBackpropFilter"
+  in_arg {
+    name: "input"
+    description: <<END
+4-D with shape `[batch, in_height, in_width, depth]`.
+END
+  }
+  in_arg {
+    name: "filter"
+    description: <<END
+3-D with shape `[filter_height, filter_width, depth]`.
+END
+  }
+  in_arg {
+    name: "out_backprop"
+    description: <<END
+4-D with shape `[batch, out_height, out_width, depth]`.
+END
+  }
+  out_arg {
+    name: "filter_backprop"
+    description: <<END
+3-D with shape `[filter_height, filter_width, depth]`.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+1-D of length 4. The stride of the sliding window for each dimension of
+the input tensor. Must be: `[1, stride_height, stride_width, 1]`.
+END
+  }
+  attr {
+    name: "rates"
+    description: <<END
+1-D of length 4. The input stride for atrous morphological dilation.
+Must be: `[1, rate_height, rate_width, 1]`.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  summary: "Computes the gradient of morphological 2-D dilation with respect to the filter."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Dilation2DBackpropInput.pbtxt b/tensorflow/core/api_def/base_api/api_def_Dilation2DBackpropInput.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0f966c1aae8b0f78db95485cbdc93eb8e7e4ecaa
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Dilation2DBackpropInput.pbtxt
@@ -0,0 +1,48 @@
+op {
+  graph_op_name: "Dilation2DBackpropInput"
+  in_arg {
+    name: "input"
+    description: <<END
+4-D with shape `[batch, in_height, in_width, depth]`.
+END
+  }
+  in_arg {
+    name: "filter"
+    description: <<END
+3-D with shape `[filter_height, filter_width, depth]`.
+END
+  }
+  in_arg {
+    name: "out_backprop"
+    description: <<END
+4-D with shape `[batch, out_height, out_width, depth]`.
+END
+  }
+  out_arg {
+    name: "in_backprop"
+    description: <<END
+4-D with shape `[batch, in_height, in_width, depth]`.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+1-D of length 4. The stride of the sliding window for each dimension of
+the input tensor. Must be: `[1, stride_height, stride_width, 1]`.
+END
+  }
+  attr {
+    name: "rates"
+    description: <<END
+1-D of length 4. The input stride for atrous morphological dilation.
+Must be: `[1, rate_height, rate_width, 1]`.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  summary: "Computes the gradient of morphological 2-D dilation with respect to the input."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Div.pbtxt b/tensorflow/core/api_def/base_api/api_def_Div.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..12b6fb5b4cec00da6843cdeb1ebd7e3d53d97ba4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Div.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "Div"
+  summary: "Returns x / y element-wise."
+  description: <<END
+*NOTE*: `Div` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DrawBoundingBoxes.pbtxt b/tensorflow/core/api_def/base_api/api_def_DrawBoundingBoxes.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6c3ae09f5d6e448a34032dd3dec2280290584d13
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DrawBoundingBoxes.pbtxt
@@ -0,0 +1,37 @@
+op {
+  graph_op_name: "DrawBoundingBoxes"
+  in_arg {
+    name: "images"
+    description: <<END
+4-D with shape `[batch, height, width, depth]`. A batch of images.
+END
+  }
+  in_arg {
+    name: "boxes"
+    description: <<END
+3-D with shape `[batch, num_bounding_boxes, 4]` containing bounding
+boxes.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+4-D with the same shape as `images`. The batch of input images with
+bounding boxes drawn on the images.
+END
+  }
+  summary: "Draw bounding boxes on a batch of images."
+  description: <<END
+Outputs a copy of `images` but draws on top of the pixels zero or more bounding
+boxes specified by the locations in `boxes`. The coordinates of the each
+bounding box in `boxes` are encoded as `[y_min, x_min, y_max, x_max]`. The
+bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
+height of the underlying image.
+
+For example, if an image is 100 x 200 pixels (height x width) and the bounding
+box is `[0.1, 0.2, 0.5, 0.9]`, the upper-left and bottom-right coordinates of
+the bounding box will be `(40, 10)` to `(100, 50)` (in (x,y) coordinates).
+
+Parts of the bounding box may fall outside the image.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DynamicPartition.pbtxt b/tensorflow/core/api_def/base_api/api_def_DynamicPartition.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b5c44b5e073761262c153246d32fccaffdb34149
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DynamicPartition.pbtxt
@@ -0,0 +1,55 @@
+op {
+  graph_op_name: "DynamicPartition"
+  in_arg {
+    name: "partitions"
+    description: <<END
+Any shape.  Indices in the range `[0, num_partitions)`.
+END
+  }
+  attr {
+    name: "num_partitions"
+    description: <<END
+The number of partitions to output.
+END
+  }
+  summary: "Partitions `data` into `num_partitions` tensors using indices from `partitions`."
+  description: <<END
+For each index tuple `js` of size `partitions.ndim`, the slice `data[js, ...]`
+becomes part of `outputs[partitions[js]]`.  The slices with `partitions[js] = i`
+are placed in `outputs[i]` in lexicographic order of `js`, and the first
+dimension of `outputs[i]` is the number of entries in `partitions` equal to `i`.
+In detail,
+
+```python
+    outputs[i].shape = [sum(partitions == i)] + data.shape[partitions.ndim:]
+
+    outputs[i] = pack([data[js, ...] for js if partitions[js] == i])
+```
+
+`data.shape` must start with `partitions.shape`.
+
+For example:
+
+```python
+    # Scalar partitions.
+    partitions = 1
+    num_partitions = 2
+    data = [10, 20]
+    outputs[0] = []  # Empty with shape [0, 2]
+    outputs[1] = [[10, 20]]
+
+    # Vector partitions.
+    partitions = [0, 0, 1, 1, 0]
+    num_partitions = 2
+    data = [10, 20, 30, 40, 50]
+    outputs[0] = [10, 20, 50]
+    outputs[1] = [30, 40]
+```
+
+See `dynamic_stitch` for an example on how to merge partitions back.
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src="https://www.tensorflow.org/images/DynamicPartition.png" alt>
+</div>
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_DynamicStitch.pbtxt b/tensorflow/core/api_def/base_api/api_def_DynamicStitch.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..34bd77bc0e4c50496894a3786a3f790d00292e3e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_DynamicStitch.pbtxt
@@ -0,0 +1,68 @@
+op {
+  graph_op_name: "DynamicStitch"
+  summary: "Interleave the values from the `data` tensors into a single tensor."
+  description: <<END
+Builds a merged tensor such that
+
+```python
+    merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]
+```
+
+For example, if each `indices[m]` is scalar or vector, we have
+
+```python
+    # Scalar indices:
+    merged[indices[m], ...] = data[m][...]
+
+    # Vector indices:
+    merged[indices[m][i], ...] = data[m][i, ...]
+```
+
+Each `data[i].shape` must start with the corresponding `indices[i].shape`,
+and the rest of `data[i].shape` must be constant w.r.t. `i`.  That is, we
+must have `data[i].shape = indices[i].shape + constant`.  In terms of this
+`constant`, the output shape is
+
+    merged.shape = [max(indices)] + constant
+
+Values are merged in order, so if an index appears in both `indices[m][i]` and
+`indices[n][j]` for `(m,i) < (n,j)` the slice `data[n][j]` will appear in the
+merged result. If you do not need this guarantee, ParallelDynamicStitch might
+perform better on some devices.
+
+For example:
+
+```python
+    indices[0] = 6
+    indices[1] = [4, 1]
+    indices[2] = [[5, 2], [0, 3]]
+    data[0] = [61, 62]
+    data[1] = [[41, 42], [11, 12]]
+    data[2] = [[[51, 52], [21, 22]], [[1, 2], [31, 32]]]
+    merged = [[1, 2], [11, 12], [21, 22], [31, 32], [41, 42],
+              [51, 52], [61, 62]]
+```
+
+This method can be used to merge partitions created by `dynamic_partition`
+as illustrated on the following example:
+
+```python
+    # Apply function (increments x_i) on elements for which a certain condition
+    # apply (x_i != -1 in this example).
+    x=tf.constant([0.1, -1., 5.2, 4.3, -1., 7.4])
+    condition_mask=tf.not_equal(x,tf.constant(-1.))
+    partitioned_data = tf.dynamic_partition(
+        x, tf.cast(condition_mask, tf.int32) , 2)
+    partitioned_data[1] = partitioned_data[1] + 1.0
+    condition_indices = tf.dynamic_partition(
+        tf.range(tf.shape(x)[0]), tf.cast(condition_mask, tf.int32) , 2)
+    x = tf.dynamic_stitch(condition_indices, partitioned_data)
+    # Here x=[1.1, -1., 6.2, 5.3, -1, 8.4], the -1. values remain
+    # unchanged.
+```
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src="https://www.tensorflow.org/images/DynamicStitch.png" alt>
+</div>
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_E.pbtxt b/tensorflow/core/api_def/base_api/api_def_E.pbtxt
deleted file mode 100644
index b49146f7c4e4e1d6470241123dbe8a1fbdb741c2..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_E.pbtxt
+++ /dev/null
@@ -1,261 +0,0 @@
-op {
-  graph_op_name: "EditDistance"
-  endpoint {
-    name: "EditDistance"
-  }
-  summary: "Computes the (possibly normalized) Levenshtein Edit Distance."
-  description: <<END
-The inputs are variable-length sequences provided by SparseTensors
-  (hypothesis_indices, hypothesis_values, hypothesis_shape)
-and
-  (truth_indices, truth_values, truth_shape).
-
-The inputs are:
-END
-}
-op {
-  graph_op_name: "Elu"
-  endpoint {
-    name: "Elu"
-  }
-  summary: "Computes exponential linear: `exp(features) - 1` if < 0, `features` otherwise."
-  description: <<END
-See [Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs)
-](http://arxiv.org/abs/1511.07289)
-END
-}
-op {
-  graph_op_name: "EluGrad"
-  endpoint {
-    name: "EluGrad"
-  }
-  summary: "Computes gradients for the exponential linear (Elu) operation."
-}
-op {
-  graph_op_name: "EncodeBase64"
-  endpoint {
-    name: "EncodeBase64"
-  }
-  summary: "Encode strings into web-safe base64 format."
-  description: <<END
-Refer to the following article for more information on base64 format:
-en.wikipedia.org/wiki/Base64. Base64 strings may have padding with '=' at the
-end so that the encoded has length multiple of 4. See Padding section of the
-link above.
-
-Web-safe means that the encoder uses - and _ instead of + and /.
-END
-}
-op {
-  graph_op_name: "EncodeJpeg"
-  endpoint {
-    name: "EncodeJpeg"
-  }
-  summary: "JPEG-encode an image."
-  description: <<END
-`image` is a 3-D uint8 Tensor of shape `[height, width, channels]`.
-
-The attr `format` can be used to override the color format of the encoded
-output.  Values can be:
-
-*   `''`: Use a default format based on the number of channels in the image.
-*   `grayscale`: Output a grayscale JPEG image.  The `channels` dimension
-    of `image` must be 1.
-*   `rgb`: Output an RGB JPEG image. The `channels` dimension
-    of `image` must be 3.
-
-If `format` is not specified or is the empty string, a default format is picked
-in function of the number of channels in `image`:
-
-*   1: Output a grayscale image.
-*   3: Output an RGB image.
-END
-}
-op {
-  graph_op_name: "EncodePng"
-  endpoint {
-    name: "EncodePng"
-  }
-  summary: "PNG-encode an image."
-  description: <<END
-`image` is a 3-D uint8 or uint16 Tensor of shape `[height, width, channels]`
-where `channels` is:
-
-*   1: for grayscale.
-*   2: for grayscale + alpha.
-*   3: for RGB.
-*   4: for RGBA.
-
-The ZLIB compression level, `compression`, can be -1 for the PNG-encoder
-default or a value from 0 to 9.  9 is the highest compression level, generating
-the smallest output, but is slower.
-END
-}
-op {
-  graph_op_name: "EncodeWav"
-  endpoint {
-    name: "EncodeWav"
-  }
-  summary: "Encode audio data using the WAV file format."
-  description: <<END
-This operation will generate a string suitable to be saved out to create a .wav
-audio file. It will be encoded in the 16-bit PCM format. It takes in float
-values in the range -1.0f to 1.0f, and any outside that value will be clamped to
-that range.
-
-`audio` is a 2-D float Tensor of shape `[length, channels]`.
-`sample_rate` is a scalar Tensor holding the rate to use (e.g. 44100).
-END
-}
-op {
-  graph_op_name: "Enter"
-  endpoint {
-    name: "Enter"
-  }
-  summary: "Creates or finds a child frame, and makes `data` available to the child frame."
-  description: <<END
-This op is used together with `Exit` to create loops in the graph.
-The unique `frame_name` is used by the `Executor` to identify frames. If
-`is_constant` is true, `output` is a constant in the child frame; otherwise
-it may be changed in the child frame. At most `parallel_iterations` iterations
-are run in parallel in the child frame.
-END
-}
-op {
-  graph_op_name: "Equal"
-  endpoint {
-    name: "Equal"
-  }
-  summary: "Returns the truth value of (x == y) element-wise."
-  description: <<END
-*NOTE*: `Equal` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "Erf"
-  endpoint {
-    name: "Erf"
-  }
-  summary: "Computes the Gauss error function of `x` element-wise."
-}
-op {
-  graph_op_name: "Erfc"
-  endpoint {
-    name: "Erfc"
-  }
-  summary: "Computes the complementary error function of `x` element-wise."
-}
-op {
-  graph_op_name: "Exit"
-  endpoint {
-    name: "Exit"
-  }
-  summary: "Exits the current frame to its parent frame."
-  description: <<END
-Exit makes its input `data` available to the parent frame.
-END
-}
-op {
-  graph_op_name: "Exp"
-  endpoint {
-    name: "Exp"
-  }
-  summary: "Computes exponential of x element-wise.  \\\\(y = e^x\\\\)."
-}
-op {
-  graph_op_name: "ExpandDims"
-  endpoint {
-    name: "ExpandDims"
-  }
-  summary: "Inserts a dimension of 1 into a tensor\'s shape."
-  description: <<END
-Given a tensor `input`, this operation inserts a dimension of 1 at the
-dimension index `dim` of `input`'s shape. The dimension index `dim` starts at
-zero; if you specify a negative number for `dim` it is counted backward from
-the end.
-
-This operation is useful if you want to add a batch dimension to a single
-element. For example, if you have a single image of shape `[height, width,
-channels]`, you can make it a batch of 1 image with `expand_dims(image, 0)`,
-which will make the shape `[1, height, width, channels]`.
-
-Other examples:
-
-```
-# 't' is a tensor of shape [2]
-shape(expand_dims(t, 0)) ==> [1, 2]
-shape(expand_dims(t, 1)) ==> [2, 1]
-shape(expand_dims(t, -1)) ==> [2, 1]
-
-# 't2' is a tensor of shape [2, 3, 5]
-shape(expand_dims(t2, 0)) ==> [1, 2, 3, 5]
-shape(expand_dims(t2, 2)) ==> [2, 3, 1, 5]
-shape(expand_dims(t2, 3)) ==> [2, 3, 5, 1]
-```
-
-This operation requires that:
-
-`-1-input.dims() <= dim <= input.dims()`
-
-This operation is related to `squeeze()`, which removes dimensions of
-size 1.
-END
-}
-op {
-  graph_op_name: "Expm1"
-  endpoint {
-    name: "Expm1"
-  }
-  summary: "Computes exponential of x - 1 element-wise."
-  description: <<END
-I.e., \\(y = (\exp x) - 1\\).
-END
-}
-op {
-  graph_op_name: "ExtractGlimpse"
-  endpoint {
-    name: "ExtractGlimpse"
-  }
-  summary: "Extracts a glimpse from the input tensor."
-  description: <<END
-Returns a set of windows called glimpses extracted at location
-`offsets` from the input tensor. If the windows only partially
-overlaps the inputs, the non overlapping areas will be filled with
-random noise.
-
-The result is a 4-D tensor of shape `[batch_size, glimpse_height,
-glimpse_width, channels]`. The channels and batch dimensions are the
-same as that of the input tensor. The height and width of the output
-windows are specified in the `size` parameter.
-
-The argument `normalized` and `centered` controls how the windows are built:
-
-* If the coordinates are normalized but not centered, 0.0 and 1.0
-  correspond to the minimum and maximum of each height and width
-  dimension.
-* If the coordinates are both normalized and centered, they range from
-  -1.0 to 1.0. The coordinates (-1.0, -1.0) correspond to the upper
-  left corner, the lower right corner is located at (1.0, 1.0) and the
-  center is at (0, 0).
-* If the coordinates are not normalized they are interpreted as
-  numbers of pixels.
-END
-}
-op {
-  graph_op_name: "ExtractImagePatches"
-  endpoint {
-    name: "ExtractImagePatches"
-  }
-  summary: "Extract `patches` from `images` and put them in the \"depth\" output dimension."
-}
-op {
-  graph_op_name: "ExtractJpegShape"
-  endpoint {
-    name: "ExtractJpegShape"
-  }
-  summary: "Extract the shape information of a JPEG-encoded image."
-  description: <<END
-This op only parses the image header, so it is much faster than DecodeJpeg.
-END
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_EditDistance.pbtxt b/tensorflow/core/api_def/base_api/api_def_EditDistance.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..678c451a8aa69fcc8446b6f7a790e6e32dd388ce
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_EditDistance.pbtxt
@@ -0,0 +1,96 @@
+op {
+  graph_op_name: "EditDistance"
+  in_arg {
+    name: "hypothesis_indices"
+    description: <<END
+The indices of the hypothesis list SparseTensor.
+This is an N x R int64 matrix.
+END
+  }
+  in_arg {
+    name: "hypothesis_values"
+    description: <<END
+The values of the hypothesis list SparseTensor.
+This is an N-length vector.
+END
+  }
+  in_arg {
+    name: "hypothesis_shape"
+    description: <<END
+The shape of the hypothesis list SparseTensor.
+This is an R-length vector.
+END
+  }
+  in_arg {
+    name: "truth_indices"
+    description: <<END
+The indices of the truth list SparseTensor.
+This is an M x R int64 matrix.
+END
+  }
+  in_arg {
+    name: "truth_values"
+    description: <<END
+The values of the truth list SparseTensor.
+This is an M-length vector.
+END
+  }
+  in_arg {
+    name: "truth_shape"
+    description: <<END
+truth indices, vector.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A dense float tensor with rank R - 1.
+
+For the example input:
+
+    // hypothesis represents a 2x1 matrix with variable-length values:
+    //   (0,0) = ["a"]
+    //   (1,0) = ["b"]
+    hypothesis_indices = [[0, 0, 0],
+                          [1, 0, 0]]
+    hypothesis_values = ["a", "b"]
+    hypothesis_shape = [2, 1, 1]
+
+    // truth represents a 2x2 matrix with variable-length values:
+    //   (0,0) = []
+    //   (0,1) = ["a"]
+    //   (1,0) = ["b", "c"]
+    //   (1,1) = ["a"]
+    truth_indices = [[0, 1, 0],
+                     [1, 0, 0],
+                     [1, 0, 1],
+                     [1, 1, 0]]
+    truth_values = ["a", "b", "c", "a"]
+    truth_shape = [2, 2, 2]
+    normalize = true
+
+The output will be:
+
+    // output is a 2x2 matrix with edit distances normalized by truth lengths.
+    output = [[inf, 1.0],  // (0,0): no truth, (0,1): no hypothesis
+              [0.5, 1.0]]  // (1,0): addition, (1,1): no hypothesis
+END
+  }
+  attr {
+    name: "normalize"
+    description: <<END
+boolean (if true, edit distances are normalized by length of truth).
+
+The output is:
+END
+  }
+  summary: "Computes the (possibly normalized) Levenshtein Edit Distance."
+  description: <<END
+The inputs are variable-length sequences provided by SparseTensors
+  (hypothesis_indices, hypothesis_values, hypothesis_shape)
+and
+  (truth_indices, truth_values, truth_shape).
+
+The inputs are:
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Elu.pbtxt b/tensorflow/core/api_def/base_api/api_def_Elu.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cf3d4b73d3388e030ddef2d05d875ed2dea0e8bd
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Elu.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "Elu"
+  summary: "Computes exponential linear: `exp(features) - 1` if < 0, `features` otherwise."
+  description: <<END
+See [Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs)
+](http://arxiv.org/abs/1511.07289)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_EluGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_EluGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..41aa5a2ac78d9955419c940a999e76fb20e4795e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_EluGrad.pbtxt
@@ -0,0 +1,24 @@
+op {
+  graph_op_name: "EluGrad"
+  visibility: HIDDEN
+  in_arg {
+    name: "gradients"
+    description: <<END
+The backpropagated gradients to the corresponding Elu operation.
+END
+  }
+  in_arg {
+    name: "outputs"
+    description: <<END
+The outputs of the corresponding Elu operation.
+END
+  }
+  out_arg {
+    name: "backprops"
+    description: <<END
+The gradients: `gradients * (outputs + 1)` if outputs < 0,
+`gradients` otherwise.
+END
+  }
+  summary: "Computes gradients for the exponential linear (Elu) operation."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_EncodeBase64.pbtxt b/tensorflow/core/api_def/base_api/api_def_EncodeBase64.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f25fe05cfd33fe68f64d56b4c3ce0d9313dd8aa1
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_EncodeBase64.pbtxt
@@ -0,0 +1,30 @@
+op {
+  graph_op_name: "EncodeBase64"
+  in_arg {
+    name: "input"
+    description: <<END
+Strings to be encoded.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Input strings encoded in base64.
+END
+  }
+  attr {
+    name: "pad"
+    description: <<END
+Bool whether padding is applied at the ends.
+END
+  }
+  summary: "Encode strings into web-safe base64 format."
+  description: <<END
+Refer to the following article for more information on base64 format:
+en.wikipedia.org/wiki/Base64. Base64 strings may have padding with '=' at the
+end so that the encoded has length multiple of 4. See Padding section of the
+link above.
+
+Web-safe means that the encoder uses - and _ instead of + and /.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_EncodeJpeg.pbtxt b/tensorflow/core/api_def/base_api/api_def_EncodeJpeg.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..05a46ed29119cc735c3135ac044857052b5f19ab
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_EncodeJpeg.pbtxt
@@ -0,0 +1,89 @@
+op {
+  graph_op_name: "EncodeJpeg"
+  in_arg {
+    name: "image"
+    description: <<END
+3-D with shape `[height, width, channels]`.
+END
+  }
+  out_arg {
+    name: "contents"
+    description: <<END
+0-D. JPEG-encoded image.
+END
+  }
+  attr {
+    name: "format"
+    description: <<END
+Per pixel image format.
+END
+  }
+  attr {
+    name: "quality"
+    description: <<END
+Quality of the compression from 0 to 100 (higher is better and slower).
+END
+  }
+  attr {
+    name: "progressive"
+    description: <<END
+If True, create a JPEG that loads progressively (coarse to fine).
+END
+  }
+  attr {
+    name: "optimize_size"
+    description: <<END
+If True, spend CPU/RAM to reduce size with no quality change.
+END
+  }
+  attr {
+    name: "chroma_downsampling"
+    description: <<END
+See http://en.wikipedia.org/wiki/Chroma_subsampling.
+END
+  }
+  attr {
+    name: "density_unit"
+    description: <<END
+Unit used to specify `x_density` and `y_density`:
+pixels per inch (`'in'`) or centimeter (`'cm'`).
+END
+  }
+  attr {
+    name: "x_density"
+    description: <<END
+Horizontal pixels per density unit.
+END
+  }
+  attr {
+    name: "y_density"
+    description: <<END
+Vertical pixels per density unit.
+END
+  }
+  attr {
+    name: "xmp_metadata"
+    description: <<END
+If not empty, embed this XMP metadata in the image header.
+END
+  }
+  summary: "JPEG-encode an image."
+  description: <<END
+`image` is a 3-D uint8 Tensor of shape `[height, width, channels]`.
+
+The attr `format` can be used to override the color format of the encoded
+output.  Values can be:
+
+*   `''`: Use a default format based on the number of channels in the image.
+*   `grayscale`: Output a grayscale JPEG image.  The `channels` dimension
+    of `image` must be 1.
+*   `rgb`: Output an RGB JPEG image. The `channels` dimension
+    of `image` must be 3.
+
+If `format` is not specified or is the empty string, a default format is picked
+in function of the number of channels in `image`:
+
+*   1: Output a grayscale image.
+*   3: Output an RGB image.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_EncodePng.pbtxt b/tensorflow/core/api_def/base_api/api_def_EncodePng.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9c7d3b37334e24f1fb7c52f56ef2af1392bb6603
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_EncodePng.pbtxt
@@ -0,0 +1,35 @@
+op {
+  graph_op_name: "EncodePng"
+  in_arg {
+    name: "image"
+    description: <<END
+3-D with shape `[height, width, channels]`.
+END
+  }
+  out_arg {
+    name: "contents"
+    description: <<END
+0-D. PNG-encoded image.
+END
+  }
+  attr {
+    name: "compression"
+    description: <<END
+Compression level.
+END
+  }
+  summary: "PNG-encode an image."
+  description: <<END
+`image` is a 3-D uint8 or uint16 Tensor of shape `[height, width, channels]`
+where `channels` is:
+
+*   1: for grayscale.
+*   2: for grayscale + alpha.
+*   3: for RGB.
+*   4: for RGBA.
+
+The ZLIB compression level, `compression`, can be -1 for the PNG-encoder
+default or a value from 0 to 9.  9 is the highest compression level, generating
+the smallest output, but is slower.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_EncodeWav.pbtxt b/tensorflow/core/api_def/base_api/api_def_EncodeWav.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..54a8b1fa550796550cf2eaf90b23626e3757042a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_EncodeWav.pbtxt
@@ -0,0 +1,31 @@
+op {
+  graph_op_name: "EncodeWav"
+  in_arg {
+    name: "audio"
+    description: <<END
+2-D with shape `[length, channels]`.
+END
+  }
+  in_arg {
+    name: "sample_rate"
+    description: <<END
+Scalar containing the sample frequency.
+END
+  }
+  out_arg {
+    name: "contents"
+    description: <<END
+0-D. WAV-encoded file contents.
+END
+  }
+  summary: "Encode audio data using the WAV file format."
+  description: <<END
+This operation will generate a string suitable to be saved out to create a .wav
+audio file. It will be encoded in the 16-bit PCM format. It takes in float
+values in the range -1.0f to 1.0f, and any outside that value will be clamped to
+that range.
+
+`audio` is a 2-D float Tensor of shape `[length, channels]`.
+`sample_rate` is a scalar Tensor holding the rate to use (e.g. 44100).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Enter.pbtxt b/tensorflow/core/api_def/base_api/api_def_Enter.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..dfff8e6ddbfcb093c9ae1c8de6615229e8f955fe
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Enter.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "Enter"
+  visibility: HIDDEN
+  in_arg {
+    name: "data"
+    description: <<END
+The tensor to be made available to the child frame.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The same tensor as `data`.
+END
+  }
+  attr {
+    name: "frame_name"
+    description: <<END
+The name of the child frame.
+END
+  }
+  attr {
+    name: "is_constant"
+    description: <<END
+If true, the output is constant within the child frame.
+END
+  }
+  attr {
+    name: "parallel_iterations"
+    description: <<END
+The number of iterations allowed to run in parallel.
+END
+  }
+  summary: "Creates or finds a child frame, and makes `data` available to the child frame."
+  description: <<END
+This op is used together with `Exit` to create loops in the graph.
+The unique `frame_name` is used by the `Executor` to identify frames. If
+`is_constant` is true, `output` is a constant in the child frame; otherwise
+it may be changed in the child frame. At most `parallel_iterations` iterations
+are run in parallel in the child frame.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Equal.pbtxt b/tensorflow/core/api_def/base_api/api_def_Equal.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6ca8ef945554cd38da4e073657e32ff45c7efa07
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Equal.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "Equal"
+  summary: "Returns the truth value of (x == y) element-wise."
+  description: <<END
+*NOTE*: `Equal` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Erf.pbtxt b/tensorflow/core/api_def/base_api/api_def_Erf.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..408df8a633289e10eef39bb135e33f4847ac2efe
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Erf.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Erf"
+  summary: "Computes the Gauss error function of `x` element-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Erfc.pbtxt b/tensorflow/core/api_def/base_api/api_def_Erfc.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ad70def47f87dbd7f348cd80e553c6549f5f10a6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Erfc.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Erfc"
+  summary: "Computes the complementary error function of `x` element-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Exit.pbtxt b/tensorflow/core/api_def/base_api/api_def_Exit.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ec97b7ac04ff39d2afc1f82e47a72ff4b82c81a4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Exit.pbtxt
@@ -0,0 +1,20 @@
+op {
+  graph_op_name: "Exit"
+  visibility: HIDDEN
+  in_arg {
+    name: "data"
+    description: <<END
+The tensor to be made available to the parent frame.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The same tensor as `data`.
+END
+  }
+  summary: "Exits the current frame to its parent frame."
+  description: <<END
+Exit makes its input `data` available to the parent frame.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Exp.pbtxt b/tensorflow/core/api_def/base_api/api_def_Exp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..dd1e3d5dfceae2a133066b7e72665aed5ad30ddc
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Exp.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Exp"
+  summary: "Computes exponential of x element-wise.  \\\\(y = e^x\\\\)."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ExpandDims.pbtxt b/tensorflow/core/api_def/base_api/api_def_ExpandDims.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7b9a03f0ea619dfa5e8144c5949134f25c841584
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ExpandDims.pbtxt
@@ -0,0 +1,52 @@
+op {
+  graph_op_name: "ExpandDims"
+  in_arg {
+    name: "dim"
+    rename_to: "axis"
+    description: <<END
+0-D (scalar). Specifies the dimension index at which to
+expand the shape of `input`. Must be in the range
+`[-rank(input) - 1, rank(input)]`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Contains the same data as `input`, but its shape has an additional
+dimension of size 1 added.
+END
+  }
+  summary: "Inserts a dimension of 1 into a tensor\'s shape."
+  description: <<END
+Given a tensor `input`, this operation inserts a dimension of 1 at the
+dimension index `dim` of `input`'s shape. The dimension index `dim` starts at
+zero; if you specify a negative number for `dim` it is counted backward from
+the end.
+
+This operation is useful if you want to add a batch dimension to a single
+element. For example, if you have a single image of shape `[height, width,
+channels]`, you can make it a batch of 1 image with `expand_dims(image, 0)`,
+which will make the shape `[1, height, width, channels]`.
+
+Other examples:
+
+```
+# 't' is a tensor of shape [2]
+shape(expand_dims(t, 0)) ==> [1, 2]
+shape(expand_dims(t, 1)) ==> [2, 1]
+shape(expand_dims(t, -1)) ==> [2, 1]
+
+# 't2' is a tensor of shape [2, 3, 5]
+shape(expand_dims(t2, 0)) ==> [1, 2, 3, 5]
+shape(expand_dims(t2, 2)) ==> [2, 3, 1, 5]
+shape(expand_dims(t2, 3)) ==> [2, 3, 5, 1]
+```
+
+This operation requires that:
+
+`-1-input.dims() <= dim <= input.dims()`
+
+This operation is related to `squeeze()`, which removes dimensions of
+size 1.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Expm1.pbtxt b/tensorflow/core/api_def/base_api/api_def_Expm1.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a048f2aa8b1c3193ad1d85e118ba637476ed8b80
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Expm1.pbtxt
@@ -0,0 +1,7 @@
+op {
+  graph_op_name: "Expm1"
+  summary: "Computes exponential of x - 1 element-wise."
+  description: <<END
+I.e., \\(y = (\exp x) - 1\\).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ExtractGlimpse.pbtxt b/tensorflow/core/api_def/base_api/api_def_ExtractGlimpse.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c10a1bb778e1d8b45b59113d255d69c55a224643
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ExtractGlimpse.pbtxt
@@ -0,0 +1,77 @@
+op {
+  graph_op_name: "ExtractGlimpse"
+  in_arg {
+    name: "input"
+    description: <<END
+A 4-D float tensor of shape `[batch_size, height, width, channels]`.
+END
+  }
+  in_arg {
+    name: "size"
+    description: <<END
+A 1-D tensor of 2 elements containing the size of the glimpses
+to extract.  The glimpse height must be specified first, following
+by the glimpse width.
+END
+  }
+  in_arg {
+    name: "offsets"
+    description: <<END
+A 2-D integer tensor of shape `[batch_size, 2]` containing
+the y, x locations of the center of each window.
+END
+  }
+  out_arg {
+    name: "glimpse"
+    description: <<END
+A tensor representing the glimpses `[batch_size,
+glimpse_height, glimpse_width, channels]`.
+END
+  }
+  attr {
+    name: "centered"
+    description: <<END
+indicates if the offset coordinates are centered relative to
+the image, in which case the (0, 0) offset is relative to the center
+of the input images. If false, the (0,0) offset corresponds to the
+upper left corner of the input images.
+END
+  }
+  attr {
+    name: "normalized"
+    description: <<END
+indicates if the offset coordinates are normalized.
+END
+  }
+  attr {
+    name: "uniform_noise"
+    description: <<END
+indicates if the noise should be generated using a
+uniform distribution or a Gaussian distribution.
+END
+  }
+  summary: "Extracts a glimpse from the input tensor."
+  description: <<END
+Returns a set of windows called glimpses extracted at location
+`offsets` from the input tensor. If the windows only partially
+overlaps the inputs, the non overlapping areas will be filled with
+random noise.
+
+The result is a 4-D tensor of shape `[batch_size, glimpse_height,
+glimpse_width, channels]`. The channels and batch dimensions are the
+same as that of the input tensor. The height and width of the output
+windows are specified in the `size` parameter.
+
+The argument `normalized` and `centered` controls how the windows are built:
+
+* If the coordinates are normalized but not centered, 0.0 and 1.0
+  correspond to the minimum and maximum of each height and width
+  dimension.
+* If the coordinates are both normalized and centered, they range from
+  -1.0 to 1.0. The coordinates (-1.0, -1.0) correspond to the upper
+  left corner, the lower right corner is located at (1.0, 1.0) and the
+  center is at (0, 0).
+* If the coordinates are not normalized they are interpreted as
+  numbers of pixels.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ExtractImagePatches.pbtxt b/tensorflow/core/api_def/base_api/api_def_ExtractImagePatches.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..712a3b0a0f92145eeab7a5e557072b4220184124
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ExtractImagePatches.pbtxt
@@ -0,0 +1,57 @@
+op {
+  graph_op_name: "ExtractImagePatches"
+  in_arg {
+    name: "images"
+    description: <<END
+4-D Tensor with shape `[batch, in_rows, in_cols, depth]`.
+END
+  }
+  out_arg {
+    name: "patches"
+    description: <<END
+4-D Tensor with shape `[batch, out_rows, out_cols, ksize_rows *
+ksize_cols * depth]` containing image patches with size
+`ksize_rows x ksize_cols x depth` vectorized in the "depth" dimension. Note
+`out_rows` and `out_cols` are the dimensions of the output patches.
+END
+  }
+  attr {
+    name: "ksizes"
+    description: <<END
+The size of the sliding window for each dimension of `images`.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+1-D of length 4. How far the centers of two consecutive patches are in
+the images. Must be: `[1, stride_rows, stride_cols, 1]`.
+END
+  }
+  attr {
+    name: "rates"
+    description: <<END
+1-D of length 4. Must be: `[1, rate_rows, rate_cols, 1]`. This is the
+input stride, specifying how far two consecutive patch samples are in the
+input. Equivalent to extracting patches with
+`patch_sizes_eff = patch_sizes + (patch_sizes - 1) * (rates - 1)`, followed by
+subsampling them spatially by a factor of `rates`. This is equivalent to
+`rate` in dilated (a.k.a. Atrous) convolutions.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+
+We specify the size-related attributes as:
+
+```python
+      ksizes = [1, ksize_rows, ksize_cols, 1]
+      strides = [1, strides_rows, strides_cols, 1]
+      rates = [1, rates_rows, rates_cols, 1]
+```
+END
+  }
+  summary: "Extract `patches` from `images` and put them in the \"depth\" output dimension."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ExtractJpegShape.pbtxt b/tensorflow/core/api_def/base_api/api_def_ExtractJpegShape.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c604adf449f56b5e91c8ee321a2f959073b0503a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ExtractJpegShape.pbtxt
@@ -0,0 +1,26 @@
+op {
+  graph_op_name: "ExtractJpegShape"
+  in_arg {
+    name: "contents"
+    description: <<END
+0-D. The JPEG-encoded image.
+END
+  }
+  out_arg {
+    name: "image_shape"
+    description: <<END
+1-D. The image shape with format [height, width, channels].
+END
+  }
+  attr {
+    name: "output_type"
+    description: <<END
+(Optional) The output type of the operation (int32 or int64).
+Defaults to int32.
+END
+  }
+  summary: "Extract the shape information of a JPEG-encoded image."
+  description: <<END
+This op only parses the image header, so it is much faster than DecodeJpeg.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_F.pbtxt b/tensorflow/core/api_def/base_api/api_def_F.pbtxt
deleted file mode 100644
index 8c073d3369c21afedcb35d4ce414e6498156af52..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_F.pbtxt
+++ /dev/null
@@ -1,411 +0,0 @@
-op {
-  graph_op_name: "FFT"
-  endpoint {
-    name: "FFT"
-  }
-  summary: "Fast Fourier transform."
-  description: <<END
-Computes the 1-dimensional discrete Fourier transform over the inner-most
-dimension of `input`.
-END
-}
-op {
-  graph_op_name: "FFT2D"
-  endpoint {
-    name: "FFT2D"
-  }
-  summary: "2D fast Fourier transform."
-  description: <<END
-Computes the 2-dimensional discrete Fourier transform over the inner-most
-2 dimensions of `input`.
-END
-}
-op {
-  graph_op_name: "FFT3D"
-  endpoint {
-    name: "FFT3D"
-  }
-  summary: "3D fast Fourier transform."
-  description: <<END
-Computes the 3-dimensional discrete Fourier transform over the inner-most 3
-dimensions of `input`.
-END
-}
-op {
-  graph_op_name: "FIFOQueue"
-  endpoint {
-    name: "FIFOQueue"
-  }
-  summary: "A queue that produces elements in first-in first-out order."
-}
-op {
-  graph_op_name: "FIFOQueueV2"
-  endpoint {
-    name: "FIFOQueueV2"
-  }
-  summary: "A queue that produces elements in first-in first-out order."
-}
-op {
-  graph_op_name: "Fact"
-  endpoint {
-    name: "Fact"
-  }
-  summary: "Output a fact about factorials."
-}
-op {
-  graph_op_name: "FakeQuantWithMinMaxArgs"
-  endpoint {
-    name: "FakeQuantWithMinMaxArgs"
-  }
-  summary: "Fake-quantize the \'inputs\' tensor, type float to \'outputs\' tensor of same type."
-  description: <<END
-Attributes `[min; max]` define the clamping range for the `inputs` data.
-`inputs` values are quantized into the quantization range (`[0; 2^num_bits - 1]`
-when `narrow_range` is false and `[1; 2^num_bits - 1]` when it is true) and
-then de-quantized and output as floats in `[min; max]` interval.
-`num_bits` is the bitwidth of the quantization; between 2 and 8, inclusive.
-
-Quantization is called fake since the output is still in floating point.
-END
-}
-op {
-  graph_op_name: "FakeQuantWithMinMaxArgsGradient"
-  endpoint {
-    name: "FakeQuantWithMinMaxArgsGradient"
-  }
-  summary: "Compute gradients for a FakeQuantWithMinMaxArgs operation."
-}
-op {
-  graph_op_name: "FakeQuantWithMinMaxVars"
-  endpoint {
-    name: "FakeQuantWithMinMaxVars"
-  }
-  summary: "Fake-quantize the \'inputs\' tensor of type float via global float scalars `min`"
-  description: <<END
-and `max` to 'outputs' tensor of same shape as `inputs`.
-
-`[min; max]` define the clamping range for the `inputs` data.
-`inputs` values are quantized into the quantization range (`[0; 2^num_bits - 1]`
-when `narrow_range` is false and `[1; 2^num_bits - 1]` when it is true) and
-then de-quantized and output as floats in `[min; max]` interval.
-`num_bits` is the bitwidth of the quantization; between 2 and 8, inclusive.
-
-This operation has a gradient and thus allows for training `min` and `max`
-values.
-END
-}
-op {
-  graph_op_name: "FakeQuantWithMinMaxVarsGradient"
-  endpoint {
-    name: "FakeQuantWithMinMaxVarsGradient"
-  }
-  summary: "Compute gradients for a FakeQuantWithMinMaxVars operation."
-}
-op {
-  graph_op_name: "FakeQuantWithMinMaxVarsPerChannel"
-  endpoint {
-    name: "FakeQuantWithMinMaxVarsPerChannel"
-  }
-  summary: "Fake-quantize the \'inputs\' tensor of type float and one of the shapes: `[d]`,"
-  description: <<END
-`[b, d]` `[b, h, w, d]` via per-channel floats `min` and `max` of shape `[d]`
-to 'outputs' tensor of same shape as `inputs`.
-
-`[min; max]` define the clamping range for the `inputs` data.
-`inputs` values are quantized into the quantization range (`[0; 2^num_bits - 1]`
-when `narrow_range` is false and `[1; 2^num_bits - 1]` when it is true) and
-then de-quantized and output as floats in `[min; max]` interval.
-`num_bits` is the bitwidth of the quantization; between 2 and 8, inclusive.
-
-This operation has a gradient and thus allows for training `min` and `max`
-values.
-END
-}
-op {
-  graph_op_name: "FakeQuantWithMinMaxVarsPerChannelGradient"
-  endpoint {
-    name: "FakeQuantWithMinMaxVarsPerChannelGradient"
-  }
-  summary: "Compute gradients for a FakeQuantWithMinMaxVarsPerChannel operation."
-}
-op {
-  graph_op_name: "FakeQueue"
-  endpoint {
-    name: "FakeQueue"
-  }
-  summary: "Deprecated. Do not use."
-}
-op {
-  graph_op_name: "Fill"
-  endpoint {
-    name: "Fill"
-  }
-  summary: "Creates a tensor filled with a scalar value."
-  description: <<END
-This operation creates a tensor of shape `dims` and fills it with `value`.
-
-For example:
-
-```
-# Output tensor has shape [2, 3].
-fill([2, 3], 9) ==> [[9, 9, 9]
-                     [9, 9, 9]]
-```
-END
-}
-op {
-  graph_op_name: "FilterDataset"
-  endpoint {
-    name: "FilterDataset"
-  }
-  summary: "Creates a dataset containing elements of `input_dataset` matching `predicate`."
-  description: <<END
-The `predicate` function must return a scalar boolean and accept the
-following arguments:
-
-* One tensor for each component of an element of `input_dataset`.
-* One tensor for each value in `other_arguments`.
-END
-}
-op {
-  graph_op_name: "FixedLengthRecordDataset"
-  endpoint {
-    name: "FixedLengthRecordDataset"
-  }
-  summary: "Creates a dataset that emits the records from one or more binary files."
-}
-op {
-  graph_op_name: "FixedLengthRecordReader"
-  endpoint {
-    name: "FixedLengthRecordReader"
-  }
-  summary: "A Reader that outputs fixed-length records from a file."
-}
-op {
-  graph_op_name: "FixedLengthRecordReaderV2"
-  endpoint {
-    name: "FixedLengthRecordReaderV2"
-  }
-  summary: "A Reader that outputs fixed-length records from a file."
-}
-op {
-  graph_op_name: "FixedUnigramCandidateSampler"
-  endpoint {
-    name: "FixedUnigramCandidateSampler"
-  }
-  summary: "Generates labels for candidate sampling with a learned unigram distribution."
-  description: <<END
-A unigram sampler could use a fixed unigram distribution read from a
-file or passed in as an in-memory array instead of building up the distribution
-from data on the fly. There is also an option to skew the distribution by
-applying a distortion power to the weights.
-
-The vocabulary file should be in CSV-like format, with the last field
-being the weight associated with the word.
-
-For each batch, this op picks a single set of sampled candidate labels.
-
-The advantages of sampling candidates per-batch are simplicity and the
-possibility of efficient dense matrix multiplication. The disadvantage is that
-the sampled candidates must be chosen independently of the context and of the
-true labels.
-END
-}
-op {
-  graph_op_name: "FlatMapDataset"
-  endpoint {
-    name: "FlatMapDataset"
-  }
-  summary: "Creates a dataset that applies `f` to the outputs of `input_dataset`."
-  description: <<END
-Unlike MapDataset, the `f` in FlatMapDataset is expected to return a
-Dataset variant, and FlatMapDataset will flatten successive results
-into a single Dataset.
-END
-}
-op {
-  graph_op_name: "Floor"
-  endpoint {
-    name: "Floor"
-  }
-  summary: "Returns element-wise largest integer not greater than x."
-}
-op {
-  graph_op_name: "FloorDiv"
-  endpoint {
-    name: "FloorDiv"
-  }
-  summary: "Returns x // y element-wise."
-  description: <<END
-*NOTE*: `FloorDiv` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "FloorMod"
-  endpoint {
-    name: "FloorMod"
-  }
-  summary: "Returns element-wise remainder of division. When `x < 0` xor `y < 0` is"
-  description: <<END
-true, this follows Python semantics in that the result here is consistent
-with a flooring divide. E.g. `floor(x / y) * y + mod(x, y) = x`.
-
-*NOTE*: `FloorMod` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "FractionalAvgPool"
-  endpoint {
-    name: "FractionalAvgPool"
-  }
-  summary: "Performs fractional average pooling on the input."
-  description: <<END
-Fractional average pooling is similar to Fractional max pooling in the pooling
-region generation step. The only difference is that after pooling regions are
-generated, a mean operation is performed instead of a max operation in each
-pooling region.
-END
-}
-op {
-  graph_op_name: "FractionalAvgPoolGrad"
-  endpoint {
-    name: "FractionalAvgPoolGrad"
-  }
-  summary: "Computes gradient of the FractionalAvgPool function."
-  description: <<END
-Unlike FractionalMaxPoolGrad, we don't need to find arg_max for
-FractionalAvgPoolGrad, we just need to evenly back-propagate each element of
-out_backprop to those indices that form the same pooling cell. Therefore, we
-just need to know the shape of original input tensor, instead of the whole
-tensor.
-END
-}
-op {
-  graph_op_name: "FractionalMaxPool"
-  endpoint {
-    name: "FractionalMaxPool"
-  }
-  summary: "Performs fractional max pooling on the input."
-  description: <<END
-Fractional max pooling is slightly different than regular max pooling.  In
-regular max pooling, you downsize an input set by taking the maximum value of
-smaller N x N subsections of the set (often 2x2), and try to reduce the set by
-a factor of N, where N is an integer.  Fractional max pooling, as you might
-expect from the word "fractional", means that the overall reduction ratio N
-does not have to be an integer.
-
-The sizes of the pooling regions are generated randomly but are fairly uniform.
-For example, let's look at the height dimension, and the constraints on the
-list of rows that will be pool boundaries.
-
-First we define the following:
-
-1.  input_row_length : the number of rows from the input set
-2.  output_row_length : which will be smaller than the input
-3.  alpha = input_row_length / output_row_length : our reduction ratio
-4.  K = floor(alpha)
-5.  row_pooling_sequence : this is the result list of pool boundary rows
-
-Then, row_pooling_sequence should satisfy:
-
-1.  a[0] = 0 : the first value of the sequence is 0
-2.  a[end] = input_row_length : the last value of the sequence is the size
-3.  K <= (a[i+1] - a[i]) <= K+1 : all intervals are K or K+1 size
-4.  length(row_pooling_sequence) = output_row_length+1
-
-For more details on fractional max pooling, see this paper:
-[Benjamin Graham, Fractional Max-Pooling](http://arxiv.org/abs/1412.6071)
-END
-}
-op {
-  graph_op_name: "FractionalMaxPoolGrad"
-  endpoint {
-    name: "FractionalMaxPoolGrad"
-  }
-  summary: "Computes gradient of the FractionalMaxPool function."
-}
-op {
-  graph_op_name: "FusedBatchNorm"
-  endpoint {
-    name: "FusedBatchNorm"
-  }
-  summary: "Batch normalization."
-  description: <<END
-Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
-The size of 1D Tensors matches the dimension C of the 4D Tensors.
-END
-}
-op {
-  graph_op_name: "FusedBatchNormGrad"
-  endpoint {
-    name: "FusedBatchNormGrad"
-  }
-  summary: "Gradient for batch normalization."
-  description: <<END
-Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
-The size of 1D Tensors matches the dimension C of the 4D Tensors.
-END
-}
-op {
-  graph_op_name: "FusedBatchNormGradV2"
-  endpoint {
-    name: "FusedBatchNormGradV2"
-  }
-  summary: "Gradient for batch normalization."
-  description: <<END
-Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
-The size of 1D Tensors matches the dimension C of the 4D Tensors.
-END
-}
-op {
-  graph_op_name: "FusedBatchNormV2"
-  endpoint {
-    name: "FusedBatchNormV2"
-  }
-  summary: "Batch normalization."
-  description: <<END
-Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
-The size of 1D Tensors matches the dimension C of the 4D Tensors.
-END
-}
-op {
-  graph_op_name: "FusedPadConv2D"
-  endpoint {
-    name: "FusedPadConv2D"
-  }
-  summary: "Performs a padding as a preprocess during a convolution."
-  description: <<END
-Similar to FusedResizeAndPadConv2d, this op allows for an optimized
-implementation where the spatial padding transformation stage is fused with the
-im2col lookup, but in this case without the bilinear filtering required for
-resizing. Fusing the padding prevents the need to write out the intermediate
-results as whole tensors, reducing memory pressure, and we can get some latency
-gains by merging the transformation calculations.
-The data_format attribute for Conv2D isn't supported by this op, and 'NHWC'
-order is used instead.
-Internally this op uses a single per-graph scratch buffer, which means that it
-will block if multiple versions are being run in parallel. This is because this
-operator is primarily an optimization to minimize memory usage.
-END
-}
-op {
-  graph_op_name: "FusedResizeAndPadConv2D"
-  endpoint {
-    name: "FusedResizeAndPadConv2D"
-  }
-  summary: "Performs a resize and padding as a preprocess during a convolution."
-  description: <<END
-It's often possible to do spatial transformations more efficiently as part of
-the packing stage of a convolution, so this op allows for an optimized
-implementation where these stages are fused together. This prevents the need to
-write out the intermediate results as whole tensors, reducing memory pressure,
-and we can get some latency gains by merging the transformation calculations.
-The data_format attribute for Conv2D isn't supported by this op, and defaults to
-'NHWC' order.
-Internally this op uses a single per-graph scratch buffer, which means that it
-will block if multiple versions are being run in parallel. This is because this
-operator is primarily an optimization to minimize memory usage.
-END
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_FFT.pbtxt b/tensorflow/core/api_def/base_api/api_def_FFT.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4e48d6c169b6641ece5f11d5add478ce25611ee8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FFT.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "FFT"
+  in_arg {
+    name: "input"
+    description: <<END
+A complex64 tensor.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A complex64 tensor of the same shape as `input`. The inner-most
+  dimension of `input` is replaced with its 1D Fourier transform.
+
+@compatibility(numpy)
+Equivalent to np.fft.fft
+@end_compatibility
+END
+  }
+  summary: "Fast Fourier transform."
+  description: <<END
+Computes the 1-dimensional discrete Fourier transform over the inner-most
+dimension of `input`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FFT2D.pbtxt b/tensorflow/core/api_def/base_api/api_def_FFT2D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..555f8e60673d71e43dbb5d4dc17ae345606a2089
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FFT2D.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "FFT2D"
+  in_arg {
+    name: "input"
+    description: <<END
+A complex64 tensor.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A complex64 tensor of the same shape as `input`. The inner-most 2
+  dimensions of `input` are replaced with their 2D Fourier transform.
+
+@compatibility(numpy)
+Equivalent to np.fft.fft2
+@end_compatibility
+END
+  }
+  summary: "2D fast Fourier transform."
+  description: <<END
+Computes the 2-dimensional discrete Fourier transform over the inner-most
+2 dimensions of `input`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FFT3D.pbtxt b/tensorflow/core/api_def/base_api/api_def_FFT3D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..abd2e67bcebb70c5a0957996284bab53f106f5b5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FFT3D.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "FFT3D"
+  in_arg {
+    name: "input"
+    description: <<END
+A complex64 tensor.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A complex64 tensor of the same shape as `input`. The inner-most 3
+  dimensions of `input` are replaced with their 3D Fourier transform.
+
+@compatibility(numpy)
+Equivalent to np.fft.fftn with 3 dimensions.
+@end_compatibility
+END
+  }
+  summary: "3D fast Fourier transform."
+  description: <<END
+Computes the 3-dimensional discrete Fourier transform over the inner-most 3
+dimensions of `input`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FIFOQueue.pbtxt b/tensorflow/core/api_def/base_api/api_def_FIFOQueue.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..751f73d66e0247cf0b45058a8ac4567c86fbfb26
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FIFOQueue.pbtxt
@@ -0,0 +1,47 @@
+op {
+  graph_op_name: "FIFOQueue"
+  visibility: SKIP
+  out_arg {
+    name: "handle"
+    description: <<END
+The handle to the queue.
+END
+  }
+  attr {
+    name: "component_types"
+    description: <<END
+The type of each component in a value.
+END
+  }
+  attr {
+    name: "shapes"
+    description: <<END
+The shape of each component in a value. The length of this attr must
+be either 0 or the same as the length of component_types. If the length of
+this attr is 0, the shapes of queue elements are not constrained, and
+only one element may be dequeued at a time.
+END
+  }
+  attr {
+    name: "capacity"
+    description: <<END
+The upper bound on the number of elements in this queue.
+Negative numbers mean no limit.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this queue is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this queue will be shared under the given name
+across multiple sessions.
+END
+  }
+  summary: "A queue that produces elements in first-in first-out order."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FIFOQueueV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_FIFOQueueV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2f7b84ff2a7db36316b831b7e95691952ba7cffd
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FIFOQueueV2.pbtxt
@@ -0,0 +1,49 @@
+op {
+  graph_op_name: "FIFOQueueV2"
+  endpoint {
+    name: "FIFOQueue"
+  }
+  out_arg {
+    name: "handle"
+    description: <<END
+The handle to the queue.
+END
+  }
+  attr {
+    name: "component_types"
+    description: <<END
+The type of each component in a value.
+END
+  }
+  attr {
+    name: "shapes"
+    description: <<END
+The shape of each component in a value. The length of this attr must
+be either 0 or the same as the length of component_types. If the length of
+this attr is 0, the shapes of queue elements are not constrained, and
+only one element may be dequeued at a time.
+END
+  }
+  attr {
+    name: "capacity"
+    description: <<END
+The upper bound on the number of elements in this queue.
+Negative numbers mean no limit.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this queue is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this queue will be shared under the given name
+across multiple sessions.
+END
+  }
+  summary: "A queue that produces elements in first-in first-out order."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Fact.pbtxt b/tensorflow/core/api_def/base_api/api_def_Fact.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9aad4aac327bb40a18e6c6761f407acf4506e7e5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Fact.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Fact"
+  summary: "Output a fact about factorials."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxArgs.pbtxt b/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxArgs.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..561c86ddf68a4fb093d263d076fb6ccc8d408733
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxArgs.pbtxt
@@ -0,0 +1,13 @@
+op {
+  graph_op_name: "FakeQuantWithMinMaxArgs"
+  summary: "Fake-quantize the \'inputs\' tensor, type float to \'outputs\' tensor of same type."
+  description: <<END
+Attributes `[min; max]` define the clamping range for the `inputs` data.
+`inputs` values are quantized into the quantization range (`[0; 2^num_bits - 1]`
+when `narrow_range` is false and `[1; 2^num_bits - 1]` when it is true) and
+then de-quantized and output as floats in `[min; max]` interval.
+`num_bits` is the bitwidth of the quantization; between 2 and 8, inclusive.
+
+Quantization is called fake since the output is still in floating point.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxArgsGradient.pbtxt b/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxArgsGradient.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5241acc559ead80e239c352f9a51017bca8340df
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxArgsGradient.pbtxt
@@ -0,0 +1,23 @@
+op {
+  graph_op_name: "FakeQuantWithMinMaxArgsGradient"
+  in_arg {
+    name: "gradients"
+    description: <<END
+Backpropagated gradients above the FakeQuantWithMinMaxArgs operation.
+END
+  }
+  in_arg {
+    name: "inputs"
+    description: <<END
+Values passed as inputs to the FakeQuantWithMinMaxArgs operation.
+END
+  }
+  out_arg {
+    name: "backprops"
+    description: <<END
+Backpropagated gradients below the FakeQuantWithMinMaxArgs operation:
+`gradients * (inputs >= min && inputs <= max)`.
+END
+  }
+  summary: "Compute gradients for a FakeQuantWithMinMaxArgs operation."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxVars.pbtxt b/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxVars.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2713c01b27f6bc45eb6117047243f06873d4dd87
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxVars.pbtxt
@@ -0,0 +1,16 @@
+op {
+  graph_op_name: "FakeQuantWithMinMaxVars"
+  summary: "Fake-quantize the \'inputs\' tensor of type float via global float scalars `min`"
+  description: <<END
+and `max` to 'outputs' tensor of same shape as `inputs`.
+
+`[min; max]` define the clamping range for the `inputs` data.
+`inputs` values are quantized into the quantization range (`[0; 2^num_bits - 1]`
+when `narrow_range` is false and `[1; 2^num_bits - 1]` when it is true) and
+then de-quantized and output as floats in `[min; max]` interval.
+`num_bits` is the bitwidth of the quantization; between 2 and 8, inclusive.
+
+This operation has a gradient and thus allows for training `min` and `max`
+values.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxVarsGradient.pbtxt b/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxVarsGradient.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d07d3b333b71cb270ddaccdded048d2848670732
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxVarsGradient.pbtxt
@@ -0,0 +1,50 @@
+op {
+  graph_op_name: "FakeQuantWithMinMaxVarsGradient"
+  in_arg {
+    name: "gradients"
+    description: <<END
+Backpropagated gradients above the FakeQuantWithMinMaxVars operation.
+END
+  }
+  in_arg {
+    name: "inputs"
+    description: <<END
+Values passed as inputs to the FakeQuantWithMinMaxVars operation.
+min, max: Quantization interval, scalar floats.
+END
+  }
+  out_arg {
+    name: "backprops_wrt_input"
+    description: <<END
+Backpropagated gradients w.r.t. inputs:
+`gradients * (inputs >= min && inputs <= max)`.
+END
+  }
+  out_arg {
+    name: "backprop_wrt_min"
+    description: <<END
+Backpropagated gradients w.r.t. min parameter:
+`sum(gradients * (inputs < min))`.
+END
+  }
+  out_arg {
+    name: "backprop_wrt_max"
+    description: <<END
+Backpropagated gradients w.r.t. max parameter:
+`sum(gradients * (inputs > max))`.
+END
+  }
+  attr {
+    name: "num_bits"
+    description: <<END
+The bitwidth of the quantization; between 2 and 8, inclusive.
+END
+  }
+  attr {
+    name: "narrow_range"
+    description: <<END
+Whether to quantize into 2^num_bits - 1 distinct values.
+END
+  }
+  summary: "Compute gradients for a FakeQuantWithMinMaxVars operation."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxVarsPerChannel.pbtxt b/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxVarsPerChannel.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e293d4d084bc90f24ee0cc1111f750ddfa46465b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxVarsPerChannel.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "FakeQuantWithMinMaxVarsPerChannel"
+  summary: "Fake-quantize the \'inputs\' tensor of type float and one of the shapes: `[d]`,"
+  description: <<END
+`[b, d]` `[b, h, w, d]` via per-channel floats `min` and `max` of shape `[d]`
+to 'outputs' tensor of same shape as `inputs`.
+
+`[min; max]` define the clamping range for the `inputs` data.
+`inputs` values are quantized into the quantization range (`[0; 2^num_bits - 1]`
+when `narrow_range` is false and `[1; 2^num_bits - 1]` when it is true) and
+then de-quantized and output as floats in `[min; max]` interval.
+`num_bits` is the bitwidth of the quantization; between 2 and 8, inclusive.
+
+This operation has a gradient and thus allows for training `min` and `max`
+values.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxVarsPerChannelGradient.pbtxt b/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxVarsPerChannelGradient.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8a4ab368b5a8c4d8ac756513da14796ff3a41551
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FakeQuantWithMinMaxVarsPerChannelGradient.pbtxt
@@ -0,0 +1,53 @@
+op {
+  graph_op_name: "FakeQuantWithMinMaxVarsPerChannelGradient"
+  in_arg {
+    name: "gradients"
+    description: <<END
+Backpropagated gradients above the FakeQuantWithMinMaxVars operation,
+shape one of: `[d]`, `[b, d]`,  `[b, h, w, d]`.
+END
+  }
+  in_arg {
+    name: "inputs"
+    description: <<END
+Values passed as inputs to the FakeQuantWithMinMaxVars operation, shape
+  same as `gradients`.
+min, max: Quantization interval, floats of shape `[d]`.
+END
+  }
+  out_arg {
+    name: "backprops_wrt_input"
+    description: <<END
+Backpropagated gradients w.r.t. inputs, shape same as
+`inputs`:
+  `gradients * (inputs >= min && inputs <= max)`.
+END
+  }
+  out_arg {
+    name: "backprop_wrt_min"
+    description: <<END
+Backpropagated gradients w.r.t. min parameter, shape `[d]`:
+`sum_per_d(gradients * (inputs < min))`.
+END
+  }
+  out_arg {
+    name: "backprop_wrt_max"
+    description: <<END
+Backpropagated gradients w.r.t. max parameter, shape `[d]`:
+`sum_per_d(gradients * (inputs > max))`.
+END
+  }
+  attr {
+    name: "num_bits"
+    description: <<END
+The bitwidth of the quantization; between 2 and 8, inclusive.
+END
+  }
+  attr {
+    name: "narrow_range"
+    description: <<END
+Whether to quantize into 2^num_bits - 1 distinct values.
+END
+  }
+  summary: "Compute gradients for a FakeQuantWithMinMaxVarsPerChannel operation."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FakeQueue.pbtxt b/tensorflow/core/api_def/base_api/api_def_FakeQueue.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..224862246ecb8fe664e52bb569ca4d5f49e3f7d0
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FakeQueue.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "FakeQueue"
+  visibility: SKIP
+  summary: "Deprecated. Do not use."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Fill.pbtxt b/tensorflow/core/api_def/base_api/api_def_Fill.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..58262a385c356816df1d119324731dbf7176376d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Fill.pbtxt
@@ -0,0 +1,31 @@
+op {
+  graph_op_name: "Fill"
+  in_arg {
+    name: "dims"
+    description: <<END
+1-D. Represents the shape of the output tensor.
+END
+  }
+  in_arg {
+    name: "value"
+    description: <<END
+0-D (scalar). Value to fill the returned tensor.
+
+@compatibility(numpy)
+Equivalent to np.full
+@end_compatibility
+END
+  }
+  summary: "Creates a tensor filled with a scalar value."
+  description: <<END
+This operation creates a tensor of shape `dims` and fills it with `value`.
+
+For example:
+
+```
+# Output tensor has shape [2, 3].
+fill([2, 3], 9) ==> [[9, 9, 9]
+                     [9, 9, 9]]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FilterDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_FilterDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fd60c0f3785a22f456c63285bf59381e6a2a5d66
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FilterDataset.pbtxt
@@ -0,0 +1,24 @@
+op {
+  graph_op_name: "FilterDataset"
+  in_arg {
+    name: "other_arguments"
+    description: <<END
+A list of tensors, typically values that were captured when
+building a closure for `predicate`.
+END
+  }
+  attr {
+    name: "predicate"
+    description: <<END
+A function returning a scalar boolean.
+END
+  }
+  summary: "Creates a dataset containing elements of `input_dataset` matching `predicate`."
+  description: <<END
+The `predicate` function must return a scalar boolean and accept the
+following arguments:
+
+* One tensor for each component of an element of `input_dataset`.
+* One tensor for each value in `other_arguments`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FixedLengthRecordDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_FixedLengthRecordDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..651b84d0d660a0bfc0ef45dd841dfc51ee1e3340
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FixedLengthRecordDataset.pbtxt
@@ -0,0 +1,37 @@
+op {
+  graph_op_name: "FixedLengthRecordDataset"
+  in_arg {
+    name: "filenames"
+    description: <<END
+A scalar or a vector containing the name(s) of the file(s) to be
+read.
+END
+  }
+  in_arg {
+    name: "header_bytes"
+    description: <<END
+A scalar representing the number of bytes to skip at the
+beginning of a file.
+END
+  }
+  in_arg {
+    name: "record_bytes"
+    description: <<END
+A scalar representing the number of bytes in each record.
+END
+  }
+  in_arg {
+    name: "footer_bytes"
+    description: <<END
+A scalar representing the number of bytes to skip at the end
+of a file.
+END
+  }
+  in_arg {
+    name: "buffer_size"
+    description: <<END
+A scalar representing the number of bytes to buffer. Must be > 0.
+END
+  }
+  summary: "Creates a dataset that emits the records from one or more binary files."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FixedLengthRecordReader.pbtxt b/tensorflow/core/api_def/base_api/api_def_FixedLengthRecordReader.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0d7f3cbb4387101b9783296ec413cfb666ed3f21
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FixedLengthRecordReader.pbtxt
@@ -0,0 +1,50 @@
+op {
+  graph_op_name: "FixedLengthRecordReader"
+  visibility: SKIP
+  out_arg {
+    name: "reader_handle"
+    description: <<END
+The handle to reference the Reader.
+END
+  }
+  attr {
+    name: "header_bytes"
+    description: <<END
+Number of bytes in the header, defaults to 0.
+END
+  }
+  attr {
+    name: "record_bytes"
+    description: <<END
+Number of bytes in the record.
+END
+  }
+  attr {
+    name: "footer_bytes"
+    description: <<END
+Number of bytes in the footer, defaults to 0.
+END
+  }
+  attr {
+    name: "hop_bytes"
+    description: <<END
+Number of bytes to hop before each read. Default of 0 means using
+record_bytes.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this reader is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this reader is named in the given bucket
+with this shared_name. Otherwise, the node name is used instead.
+END
+  }
+  summary: "A Reader that outputs fixed-length records from a file."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FixedLengthRecordReaderV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_FixedLengthRecordReaderV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9a9067a592f8fe1da61b5ba835c38dd049e22cda
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FixedLengthRecordReaderV2.pbtxt
@@ -0,0 +1,59 @@
+op {
+  graph_op_name: "FixedLengthRecordReaderV2"
+  endpoint {
+    name: "FixedLengthRecordReader"
+  }
+  out_arg {
+    name: "reader_handle"
+    description: <<END
+The handle to reference the Reader.
+END
+  }
+  attr {
+    name: "header_bytes"
+    description: <<END
+Number of bytes in the header, defaults to 0.
+END
+  }
+  attr {
+    name: "record_bytes"
+    description: <<END
+Number of bytes in the record.
+END
+  }
+  attr {
+    name: "footer_bytes"
+    description: <<END
+Number of bytes in the footer, defaults to 0.
+END
+  }
+  attr {
+    name: "hop_bytes"
+    description: <<END
+Number of bytes to hop before each read. Default of 0 means using
+record_bytes.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this reader is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this reader is named in the given bucket
+with this shared_name. Otherwise, the node name is used instead.
+END
+  }
+  attr {
+    name: "encoding"
+    description: <<END
+The type of encoding for the file. Currently ZLIB and GZIP
+are supported. Defaults to none.
+END
+  }
+  summary: "A Reader that outputs fixed-length records from a file."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FixedUnigramCandidateSampler.pbtxt b/tensorflow/core/api_def/base_api/api_def_FixedUnigramCandidateSampler.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6c40b161225ea916433a36ff91c4668ed5bc6b68
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FixedUnigramCandidateSampler.pbtxt
@@ -0,0 +1,144 @@
+op {
+  graph_op_name: "FixedUnigramCandidateSampler"
+  in_arg {
+    name: "true_classes"
+    description: <<END
+A batch_size * num_true matrix, in which each row contains the
+IDs of the num_true target_classes in the corresponding original label.
+END
+  }
+  out_arg {
+    name: "sampled_candidates"
+    description: <<END
+A vector of length num_sampled, in which each element is
+the ID of a sampled candidate.
+END
+  }
+  out_arg {
+    name: "true_expected_count"
+    description: <<END
+A batch_size * num_true matrix, representing
+the number of times each candidate is expected to occur in a batch
+of sampled candidates. If unique=true, then this is a probability.
+END
+  }
+  out_arg {
+    name: "sampled_expected_count"
+    description: <<END
+A vector of length num_sampled, for each sampled
+candidate representing the number of times the candidate is expected
+to occur in a batch of sampled candidates.  If unique=true, then this is a
+probability.
+END
+  }
+  attr {
+    name: "num_true"
+    description: <<END
+Number of true labels per context.
+END
+  }
+  attr {
+    name: "num_sampled"
+    description: <<END
+Number of candidates to randomly sample.
+END
+  }
+  attr {
+    name: "unique"
+    description: <<END
+If unique is true, we sample with rejection, so that all sampled
+candidates in a batch are unique. This requires some approximation to
+estimate the post-rejection sampling probabilities.
+END
+  }
+  attr {
+    name: "range_max"
+    description: <<END
+The sampler will sample integers from the interval [0, range_max).
+END
+  }
+  attr {
+    name: "vocab_file"
+    description: <<END
+Each valid line in this file (which should have a CSV-like format)
+corresponds to a valid word ID. IDs are in sequential order, starting from
+num_reserved_ids. The last entry in each line is expected to be a value
+corresponding to the count or relative probability. Exactly one of vocab_file
+and unigrams needs to be passed to this op.
+END
+  }
+  attr {
+    name: "distortion"
+    description: <<END
+The distortion is used to skew the unigram probability distribution.
+Each weight is first raised to the distortion's power before adding to the
+internal unigram distribution. As a result, distortion = 1.0 gives regular
+unigram sampling (as defined by the vocab file), and distortion = 0.0 gives
+a uniform distribution.
+END
+  }
+  attr {
+    name: "num_reserved_ids"
+    description: <<END
+Optionally some reserved IDs can be added in the range [0,
+..., num_reserved_ids) by the users. One use case is that a special unknown
+word token is used as ID 0. These IDs will have a sampling probability of 0.
+END
+  }
+  attr {
+    name: "num_shards"
+    description: <<END
+A sampler can be used to sample from a subset of the original range
+in order to speed up the whole computation through parallelism. This parameter
+(together with 'shard') indicates the number of partitions that are being
+used in the overall computation.
+END
+  }
+  attr {
+    name: "shard"
+    description: <<END
+A sampler can be used to sample from a subset of the original range
+in order to speed up the whole computation through parallelism. This parameter
+(together with 'num_shards') indicates the particular partition number of a
+sampler op, when partitioning is being used.
+END
+  }
+  attr {
+    name: "unigrams"
+    description: <<END
+A list of unigram counts or probabilities, one per ID in sequential
+order. Exactly one of vocab_file and unigrams should be passed to this op.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either seed or seed2 are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+An second seed to avoid seed collision.
+END
+  }
+  summary: "Generates labels for candidate sampling with a learned unigram distribution."
+  description: <<END
+A unigram sampler could use a fixed unigram distribution read from a
+file or passed in as an in-memory array instead of building up the distribution
+from data on the fly. There is also an option to skew the distribution by
+applying a distortion power to the weights.
+
+The vocabulary file should be in CSV-like format, with the last field
+being the weight associated with the word.
+
+For each batch, this op picks a single set of sampled candidate labels.
+
+The advantages of sampling candidates per-batch are simplicity and the
+possibility of efficient dense matrix multiplication. The disadvantage is that
+the sampled candidates must be chosen independently of the context and of the
+true labels.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FlatMapDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_FlatMapDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1936119c50f5323e69465a79cda784afc68c3aca
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FlatMapDataset.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "FlatMapDataset"
+  attr {
+    name: "f"
+    description: <<END
+A function mapping elements of `input_dataset`, concatenated with
+`other_arguments`, to a Dataset variant that contains elements matching
+`output_types` and `output_shapes`.
+END
+  }
+  summary: "Creates a dataset that applies `f` to the outputs of `input_dataset`."
+  description: <<END
+Unlike MapDataset, the `f` in FlatMapDataset is expected to return a
+Dataset variant, and FlatMapDataset will flatten successive results
+into a single Dataset.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Floor.pbtxt b/tensorflow/core/api_def/base_api/api_def_Floor.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ecb697cc7a03ae3334ad934547142306e2c53ea9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Floor.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Floor"
+  summary: "Returns element-wise largest integer not greater than x."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FloorDiv.pbtxt b/tensorflow/core/api_def/base_api/api_def_FloorDiv.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..913d4a1a52119825e55362a5c624e553564349aa
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FloorDiv.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "FloorDiv"
+  summary: "Returns x // y element-wise."
+  description: <<END
+*NOTE*: `FloorDiv` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FloorMod.pbtxt b/tensorflow/core/api_def/base_api/api_def_FloorMod.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c3c0be91ae8eac6b8177d0f38937c3255d003043
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FloorMod.pbtxt
@@ -0,0 +1,11 @@
+op {
+  graph_op_name: "FloorMod"
+  summary: "Returns element-wise remainder of division. When `x < 0` xor `y < 0` is"
+  description: <<END
+true, this follows Python semantics in that the result here is consistent
+with a flooring divide. E.g. `floor(x / y) * y + mod(x, y) = x`.
+
+*NOTE*: `FloorMod` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FractionalAvgPool.pbtxt b/tensorflow/core/api_def/base_api/api_def_FractionalAvgPool.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..03495b7ea51cc22022837e7a8cb1391e58357d66
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FractionalAvgPool.pbtxt
@@ -0,0 +1,90 @@
+op {
+  graph_op_name: "FractionalAvgPool"
+  in_arg {
+    name: "value"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+output tensor after fractional avg pooling.
+END
+  }
+  out_arg {
+    name: "row_pooling_sequence"
+    description: <<END
+row pooling sequence, needed to calculate gradient.
+END
+  }
+  out_arg {
+    name: "col_pooling_sequence"
+    description: <<END
+column pooling sequence, needed to calculate gradient.
+END
+  }
+  attr {
+    name: "pooling_ratio"
+    description: <<END
+Pooling ratio for each dimension of `value`, currently only
+supports row and col dimension and should be >= 1.0. For example, a valid
+pooling ratio looks like [1.0, 1.44, 1.73, 1.0]. The first and last elements
+must be 1.0 because we don't allow pooling on batch and channels
+dimensions. 1.44 and 1.73 are pooling ratio on height and width dimensions
+respectively.
+END
+  }
+  attr {
+    name: "pseudo_random"
+    description: <<END
+When set to True, generates the pooling sequence in a
+pseudorandom fashion, otherwise, in a random fashion. Check paper [Benjamin
+Graham, Fractional Max-Pooling](http://arxiv.org/abs/1412.6071) for
+difference between pseudorandom and random.
+END
+  }
+  attr {
+    name: "overlapping"
+    description: <<END
+When set to True, it means when pooling, the values at the boundary
+of adjacent pooling cells are used by both cells. For example:
+
+`index  0  1  2  3  4`
+
+`value  20 5  16 3  7`
+
+If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
+The result would be [41/3, 26/3] for fractional avg pooling.
+END
+  }
+  attr {
+    name: "deterministic"
+    description: <<END
+When set to True, a fixed pooling region will be used when
+iterating over a FractionalAvgPool node in the computation graph. Mainly used
+in unit test to make FractionalAvgPool deterministic.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either seed or seed2 are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+An second seed to avoid seed collision.
+END
+  }
+  summary: "Performs fractional average pooling on the input."
+  description: <<END
+Fractional average pooling is similar to Fractional max pooling in the pooling
+region generation step. The only difference is that after pooling regions are
+generated, a mean operation is performed instead of a max operation in each
+pooling region.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FractionalAvgPoolGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_FractionalAvgPoolGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a0cda03295945ee86f0f4e9d77159bdd7f9b2ab9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FractionalAvgPoolGrad.pbtxt
@@ -0,0 +1,59 @@
+op {
+  graph_op_name: "FractionalAvgPoolGrad"
+  visibility: HIDDEN
+  in_arg {
+    name: "orig_input_tensor_shape"
+    description: <<END
+Original input tensor shape for `fractional_avg_pool`
+END
+  }
+  in_arg {
+    name: "out_backprop"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.  Gradients
+w.r.t. the output of `fractional_avg_pool`.
+END
+  }
+  in_arg {
+    name: "row_pooling_sequence"
+    description: <<END
+row pooling sequence, form pooling region with
+col_pooling_sequence.
+END
+  }
+  in_arg {
+    name: "col_pooling_sequence"
+    description: <<END
+column pooling sequence, form pooling region with
+row_pooling sequence.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+4-D.  Gradients w.r.t. the input of `fractional_avg_pool`.
+END
+  }
+  attr {
+    name: "overlapping"
+    description: <<END
+When set to True, it means when pooling, the values at the boundary
+of adjacent pooling cells are used by both cells. For example:
+
+`index  0  1  2  3  4`
+
+`value  20 5  16 3  7`
+
+If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
+The result would be [41/3, 26/3] for fractional avg pooling.
+END
+  }
+  summary: "Computes gradient of the FractionalAvgPool function."
+  description: <<END
+Unlike FractionalMaxPoolGrad, we don't need to find arg_max for
+FractionalAvgPoolGrad, we just need to evenly back-propagate each element of
+out_backprop to those indices that form the same pooling cell. Therefore, we
+just need to know the shape of original input tensor, instead of the whole
+tensor.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FractionalMaxPool.pbtxt b/tensorflow/core/api_def/base_api/api_def_FractionalMaxPool.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..efc7719329dabee1e50f13e325c791988f11a562
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FractionalMaxPool.pbtxt
@@ -0,0 +1,114 @@
+op {
+  graph_op_name: "FractionalMaxPool"
+  in_arg {
+    name: "value"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+output tensor after fractional max pooling.
+END
+  }
+  out_arg {
+    name: "row_pooling_sequence"
+    description: <<END
+row pooling sequence, needed to calculate gradient.
+END
+  }
+  out_arg {
+    name: "col_pooling_sequence"
+    description: <<END
+column pooling sequence, needed to calculate gradient.
+END
+  }
+  attr {
+    name: "pooling_ratio"
+    description: <<END
+Pooling ratio for each dimension of `value`, currently only
+supports row and col dimension and should be >= 1.0. For example, a valid
+pooling ratio looks like [1.0, 1.44, 1.73, 1.0]. The first and last elements
+must be 1.0 because we don't allow pooling on batch and channels
+dimensions. 1.44 and 1.73 are pooling ratio on height and width dimensions
+respectively.
+END
+  }
+  attr {
+    name: "pseudo_random"
+    description: <<END
+When set to True, generates the pooling sequence in a
+pseudorandom fashion, otherwise, in a random fashion. Check paper [Benjamin
+Graham, Fractional Max-Pooling](http://arxiv.org/abs/1412.6071) for
+difference between pseudorandom and random.
+END
+  }
+  attr {
+    name: "overlapping"
+    description: <<END
+When set to True, it means when pooling, the values at the boundary
+of adjacent pooling cells are used by both cells. For example:
+
+`index  0  1  2  3  4`
+
+`value  20 5  16 3  7`
+
+If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
+The result would be [20, 16] for fractional max pooling.
+END
+  }
+  attr {
+    name: "deterministic"
+    description: <<END
+When set to True, a fixed pooling region will be used when
+iterating over a FractionalMaxPool node in the computation graph. Mainly used
+in unit test to make FractionalMaxPool deterministic.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either seed or seed2 are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+An second seed to avoid seed collision.
+END
+  }
+  summary: "Performs fractional max pooling on the input."
+  description: <<END
+Fractional max pooling is slightly different than regular max pooling.  In
+regular max pooling, you downsize an input set by taking the maximum value of
+smaller N x N subsections of the set (often 2x2), and try to reduce the set by
+a factor of N, where N is an integer.  Fractional max pooling, as you might
+expect from the word "fractional", means that the overall reduction ratio N
+does not have to be an integer.
+
+The sizes of the pooling regions are generated randomly but are fairly uniform.
+For example, let's look at the height dimension, and the constraints on the
+list of rows that will be pool boundaries.
+
+First we define the following:
+
+1.  input_row_length : the number of rows from the input set
+2.  output_row_length : which will be smaller than the input
+3.  alpha = input_row_length / output_row_length : our reduction ratio
+4.  K = floor(alpha)
+5.  row_pooling_sequence : this is the result list of pool boundary rows
+
+Then, row_pooling_sequence should satisfy:
+
+1.  a[0] = 0 : the first value of the sequence is 0
+2.  a[end] = input_row_length : the last value of the sequence is the size
+3.  K <= (a[i+1] - a[i]) <= K+1 : all intervals are K or K+1 size
+4.  length(row_pooling_sequence) = output_row_length+1
+
+For more details on fractional max pooling, see this paper:
+[Benjamin Graham, Fractional Max-Pooling](http://arxiv.org/abs/1412.6071)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FractionalMaxPoolGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_FractionalMaxPoolGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d7faa5b24a04e4cd31d4d2a8c84427307e6a6015
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FractionalMaxPoolGrad.pbtxt
@@ -0,0 +1,58 @@
+op {
+  graph_op_name: "FractionalMaxPoolGrad"
+  visibility: HIDDEN
+  in_arg {
+    name: "orig_input"
+    description: <<END
+Original input for `fractional_max_pool`
+END
+  }
+  in_arg {
+    name: "orig_output"
+    description: <<END
+Original output for `fractional_max_pool`
+END
+  }
+  in_arg {
+    name: "out_backprop"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.  Gradients
+w.r.t. the output of `fractional_max_pool`.
+END
+  }
+  in_arg {
+    name: "row_pooling_sequence"
+    description: <<END
+row pooling sequence, form pooling region with
+col_pooling_sequence.
+END
+  }
+  in_arg {
+    name: "col_pooling_sequence"
+    description: <<END
+column pooling sequence, form pooling region with
+row_pooling sequence.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+4-D.  Gradients w.r.t. the input of `fractional_max_pool`.
+END
+  }
+  attr {
+    name: "overlapping"
+    description: <<END
+When set to True, it means when pooling, the values at the boundary
+of adjacent pooling cells are used by both cells. For example:
+
+`index  0  1  2  3  4`
+
+`value  20 5  16 3  7`
+
+If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
+The result would be [20, 16] for fractional max pooling.
+END
+  }
+  summary: "Computes gradient of the FractionalMaxPool function."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FusedBatchNorm.pbtxt b/tensorflow/core/api_def/base_api/api_def_FusedBatchNorm.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8f065d96fc20eac081a309e06a2367ce016be84d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FusedBatchNorm.pbtxt
@@ -0,0 +1,99 @@
+op {
+  graph_op_name: "FusedBatchNorm"
+  in_arg {
+    name: "x"
+    description: <<END
+A 4D Tensor for input data.
+END
+  }
+  in_arg {
+    name: "scale"
+    description: <<END
+A 1D Tensor for scaling factor, to scale the normalized x.
+END
+  }
+  in_arg {
+    name: "offset"
+    description: <<END
+A 1D Tensor for offset, to shift to the normalized x.
+END
+  }
+  in_arg {
+    name: "mean"
+    description: <<END
+A 1D Tensor for population mean. Used for inference only;
+must be empty for training.
+END
+  }
+  in_arg {
+    name: "variance"
+    description: <<END
+A 1D Tensor for population variance. Used for inference only;
+must be empty for training.
+END
+  }
+  out_arg {
+    name: "y"
+    description: <<END
+A 4D Tensor for output data.
+END
+  }
+  out_arg {
+    name: "batch_mean"
+    description: <<END
+A 1D Tensor for the computed batch mean, to be used by TensorFlow
+to compute the running mean.
+END
+  }
+  out_arg {
+    name: "batch_variance"
+    description: <<END
+A 1D Tensor for the computed batch variance, to be used by
+TensorFlow to compute the running variance.
+END
+  }
+  out_arg {
+    name: "reserve_space_1"
+    description: <<END
+A 1D Tensor for the computed batch mean, to be reused
+in the gradient computation.
+END
+  }
+  out_arg {
+    name: "reserve_space_2"
+    description: <<END
+A 1D Tensor for the computed batch variance (inverted variance
+in the cuDNN case), to be reused in the gradient computation.
+END
+  }
+  attr {
+    name: "T"
+    description: <<END
+The data type for the elements of input and output Tensors.
+END
+  }
+  attr {
+    name: "epsilon"
+    description: <<END
+A small float number added to the variance of x.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+The data format for x and y. Either "NHWC" (default) or "NCHW".
+END
+  }
+  attr {
+    name: "is_training"
+    description: <<END
+A bool value to indicate the operation is for training (default)
+or inference.
+END
+  }
+  summary: "Batch normalization."
+  description: <<END
+Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
+The size of 1D Tensors matches the dimension C of the 4D Tensors.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FusedBatchNormGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_FusedBatchNormGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3d436e36906cdbde2967cc49d1b7f9e86c7fe77d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FusedBatchNormGrad.pbtxt
@@ -0,0 +1,102 @@
+op {
+  graph_op_name: "FusedBatchNormGrad"
+  in_arg {
+    name: "y_backprop"
+    description: <<END
+A 4D Tensor for the gradient with respect to y.
+END
+  }
+  in_arg {
+    name: "x"
+    description: <<END
+A 4D Tensor for input data.
+END
+  }
+  in_arg {
+    name: "scale"
+    description: <<END
+A 1D Tensor for scaling factor, to scale the normalized x.
+END
+  }
+  in_arg {
+    name: "reserve_space_1"
+    description: <<END
+When is_training is True, a 1D Tensor for the computed batch
+mean to be reused in gradient computation. When is_training is
+False, a 1D Tensor for the population mean to be reused in both
+1st and 2nd order gradient computation.
+END
+  }
+  in_arg {
+    name: "reserve_space_2"
+    description: <<END
+When is_training is True, a 1D Tensor for the computed batch
+variance (inverted variance in the cuDNN case) to be reused in
+gradient computation. When is_training is False, a 1D Tensor
+for the population variance to be reused in both 1st and 2nd
+order gradient computation.
+END
+  }
+  out_arg {
+    name: "x_backprop"
+    description: <<END
+A 4D Tensor for the gradient with respect to x.
+END
+  }
+  out_arg {
+    name: "scale_backprop"
+    description: <<END
+A 1D Tensor for the gradient with respect to scale.
+END
+  }
+  out_arg {
+    name: "offset_backprop"
+    description: <<END
+A 1D Tensor for the gradient with respect to offset.
+END
+  }
+  out_arg {
+    name: "reserve_space_3"
+    description: <<END
+Unused placeholder to match the mean input in FusedBatchNorm.
+END
+  }
+  out_arg {
+    name: "reserve_space_4"
+    description: <<END
+Unused placeholder to match the variance input
+in FusedBatchNorm.
+END
+  }
+  attr {
+    name: "T"
+    description: <<END
+The data type for the elements of input and output Tensors.
+END
+  }
+  attr {
+    name: "epsilon"
+    description: <<END
+A small float number added to the variance of x.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+The data format for y_backprop, x, x_backprop.
+Either "NHWC" (default) or "NCHW".
+END
+  }
+  attr {
+    name: "is_training"
+    description: <<END
+A bool value to indicate the operation is for training (default)
+or inference.
+END
+  }
+  summary: "Gradient for batch normalization."
+  description: <<END
+Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
+The size of 1D Tensors matches the dimension C of the 4D Tensors.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FusedBatchNormGradV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_FusedBatchNormGradV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d8f04093a41b7a1418e67f344b0044cdf3ebcde6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FusedBatchNormGradV2.pbtxt
@@ -0,0 +1,108 @@
+op {
+  graph_op_name: "FusedBatchNormGradV2"
+  in_arg {
+    name: "y_backprop"
+    description: <<END
+A 4D Tensor for the gradient with respect to y.
+END
+  }
+  in_arg {
+    name: "x"
+    description: <<END
+A 4D Tensor for input data.
+END
+  }
+  in_arg {
+    name: "scale"
+    description: <<END
+A 1D Tensor for scaling factor, to scale the normalized x.
+END
+  }
+  in_arg {
+    name: "reserve_space_1"
+    description: <<END
+When is_training is True, a 1D Tensor for the computed batch
+mean to be reused in gradient computation. When is_training is
+False, a 1D Tensor for the population mean to be reused in both
+1st and 2nd order gradient computation.
+END
+  }
+  in_arg {
+    name: "reserve_space_2"
+    description: <<END
+When is_training is True, a 1D Tensor for the computed batch
+variance (inverted variance in the cuDNN case) to be reused in
+gradient computation. When is_training is False, a 1D Tensor
+for the population variance to be reused in both 1st and 2nd
+order gradient computation.
+END
+  }
+  out_arg {
+    name: "x_backprop"
+    description: <<END
+A 4D Tensor for the gradient with respect to x.
+END
+  }
+  out_arg {
+    name: "scale_backprop"
+    description: <<END
+A 1D Tensor for the gradient with respect to scale.
+END
+  }
+  out_arg {
+    name: "offset_backprop"
+    description: <<END
+A 1D Tensor for the gradient with respect to offset.
+END
+  }
+  out_arg {
+    name: "reserve_space_3"
+    description: <<END
+Unused placeholder to match the mean input in FusedBatchNorm.
+END
+  }
+  out_arg {
+    name: "reserve_space_4"
+    description: <<END
+Unused placeholder to match the variance input
+in FusedBatchNorm.
+END
+  }
+  attr {
+    name: "T"
+    description: <<END
+The data type for the elements of input and output Tensors.
+END
+  }
+  attr {
+    name: "U"
+    description: <<END
+The data type for the scale, offset, mean, and variance.
+END
+  }
+  attr {
+    name: "epsilon"
+    description: <<END
+A small float number added to the variance of x.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+The data format for y_backprop, x, x_backprop.
+Either "NHWC" (default) or "NCHW".
+END
+  }
+  attr {
+    name: "is_training"
+    description: <<END
+A bool value to indicate the operation is for training (default)
+or inference.
+END
+  }
+  summary: "Gradient for batch normalization."
+  description: <<END
+Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
+The size of 1D Tensors matches the dimension C of the 4D Tensors.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FusedBatchNormV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_FusedBatchNormV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..df14adf49d015875dc05db25a7abb2e69a82b068
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FusedBatchNormV2.pbtxt
@@ -0,0 +1,105 @@
+op {
+  graph_op_name: "FusedBatchNormV2"
+  in_arg {
+    name: "x"
+    description: <<END
+A 4D Tensor for input data.
+END
+  }
+  in_arg {
+    name: "scale"
+    description: <<END
+A 1D Tensor for scaling factor, to scale the normalized x.
+END
+  }
+  in_arg {
+    name: "offset"
+    description: <<END
+A 1D Tensor for offset, to shift to the normalized x.
+END
+  }
+  in_arg {
+    name: "mean"
+    description: <<END
+A 1D Tensor for population mean. Used for inference only;
+must be empty for training.
+END
+  }
+  in_arg {
+    name: "variance"
+    description: <<END
+A 1D Tensor for population variance. Used for inference only;
+must be empty for training.
+END
+  }
+  out_arg {
+    name: "y"
+    description: <<END
+A 4D Tensor for output data.
+END
+  }
+  out_arg {
+    name: "batch_mean"
+    description: <<END
+A 1D Tensor for the computed batch mean, to be used by TensorFlow
+to compute the running mean.
+END
+  }
+  out_arg {
+    name: "batch_variance"
+    description: <<END
+A 1D Tensor for the computed batch variance, to be used by
+TensorFlow to compute the running variance.
+END
+  }
+  out_arg {
+    name: "reserve_space_1"
+    description: <<END
+A 1D Tensor for the computed batch mean, to be reused
+in the gradient computation.
+END
+  }
+  out_arg {
+    name: "reserve_space_2"
+    description: <<END
+A 1D Tensor for the computed batch variance (inverted variance
+in the cuDNN case), to be reused in the gradient computation.
+END
+  }
+  attr {
+    name: "T"
+    description: <<END
+The data type for the elements of input and output Tensors.
+END
+  }
+  attr {
+    name: "U"
+    description: <<END
+The data type for the scale, offset, mean, and variance.
+END
+  }
+  attr {
+    name: "epsilon"
+    description: <<END
+A small float number added to the variance of x.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+The data format for x and y. Either "NHWC" (default) or "NCHW".
+END
+  }
+  attr {
+    name: "is_training"
+    description: <<END
+A bool value to indicate the operation is for training (default)
+or inference.
+END
+  }
+  summary: "Batch normalization."
+  description: <<END
+Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
+The size of 1D Tensors matches the dimension C of the 4D Tensors.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FusedPadConv2D.pbtxt b/tensorflow/core/api_def/base_api/api_def_FusedPadConv2D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5c2c3eb0c5396dc2c6bce2527a250a995ee13a91
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FusedPadConv2D.pbtxt
@@ -0,0 +1,50 @@
+op {
+  graph_op_name: "FusedPadConv2D"
+  in_arg {
+    name: "input"
+    description: <<END
+4-D with shape `[batch, in_height, in_width, in_channels]`.
+END
+  }
+  in_arg {
+    name: "paddings"
+    description: <<END
+A two-column matrix specifying the padding sizes. The number of
+rows must be the same as the rank of `input`.
+END
+  }
+  in_arg {
+    name: "filter"
+    description: <<END
+4-D with shape
+`[filter_height, filter_width, in_channels, out_channels]`.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+1-D of length 4.  The stride of the sliding window for each dimension
+of `input`. Must be in the same order as the dimension specified with format.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  summary: "Performs a padding as a preprocess during a convolution."
+  description: <<END
+Similar to FusedResizeAndPadConv2d, this op allows for an optimized
+implementation where the spatial padding transformation stage is fused with the
+im2col lookup, but in this case without the bilinear filtering required for
+resizing. Fusing the padding prevents the need to write out the intermediate
+results as whole tensors, reducing memory pressure, and we can get some latency
+gains by merging the transformation calculations.
+The data_format attribute for Conv2D isn't supported by this op, and 'NHWC'
+order is used instead.
+Internally this op uses a single per-graph scratch buffer, which means that it
+will block if multiple versions are being run in parallel. This is because this
+operator is primarily an optimization to minimize memory usage.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_FusedResizeAndPadConv2D.pbtxt b/tensorflow/core/api_def/base_api/api_def_FusedResizeAndPadConv2D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a72f2bfe5fc90ed7055a0d5354af81f8eee6a7d8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_FusedResizeAndPadConv2D.pbtxt
@@ -0,0 +1,64 @@
+op {
+  graph_op_name: "FusedResizeAndPadConv2D"
+  in_arg {
+    name: "input"
+    description: <<END
+4-D with shape `[batch, in_height, in_width, in_channels]`.
+END
+  }
+  in_arg {
+    name: "size"
+    description: <<END
+A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+new size for the images.
+END
+  }
+  in_arg {
+    name: "paddings"
+    description: <<END
+A two-column matrix specifying the padding sizes. The number of
+rows must be the same as the rank of `input`.
+END
+  }
+  in_arg {
+    name: "filter"
+    description: <<END
+4-D with shape
+`[filter_height, filter_width, in_channels, out_channels]`.
+END
+  }
+  attr {
+    name: "resize_align_corners"
+    description: <<END
+If true, rescale input by (new_height - 1) / (height - 1),
+which exactly aligns the 4 corners of images and resized images. If false, rescale
+by new_height / height. Treat similarly the width dimension.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+1-D of length 4.  The stride of the sliding window for each dimension
+of `input`. Must be in the same order as the dimension specified with format.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  summary: "Performs a resize and padding as a preprocess during a convolution."
+  description: <<END
+It's often possible to do spatial transformations more efficiently as part of
+the packing stage of a convolution, so this op allows for an optimized
+implementation where these stages are fused together. This prevents the need to
+write out the intermediate results as whole tensors, reducing memory pressure,
+and we can get some latency gains by merging the transformation calculations.
+The data_format attribute for Conv2D isn't supported by this op, and defaults to
+'NHWC' order.
+Internally this op uses a single per-graph scratch buffer, which means that it
+will block if multiple versions are being run in parallel. This is because this
+operator is primarily an optimization to minimize memory usage.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_G.pbtxt b/tensorflow/core/api_def/base_api/api_def_G.pbtxt
deleted file mode 100644
index 343d505718149cf09c12a777a8b025ee176e4d2f..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_G.pbtxt
+++ /dev/null
@@ -1,257 +0,0 @@
-op {
-  graph_op_name: "Gather"
-  endpoint {
-    name: "Gather"
-  }
-  summary: "Gather slices from `params` according to `indices`."
-  description: <<END
-`indices` must be an integer tensor of any dimension (usually 0-D or 1-D).
-Produces an output tensor with shape `indices.shape + params.shape[1:]` where:
-
-```python
-    # Scalar indices
-    output[:, ..., :] = params[indices, :, ... :]
-
-    # Vector indices
-    output[i, :, ..., :] = params[indices[i], :, ... :]
-
-    # Higher rank indices
-    output[i, ..., j, :, ... :] = params[indices[i, ..., j], :, ..., :]
-```
-
-If `indices` is a permutation and `len(indices) == params.shape[0]` then
-this operation will permute `params` accordingly.
-
-`validate_indices`: DEPRECATED. If this operation is assigned to CPU, values in
-`indices` are always validated to be within range. If assigned to GPU,
-out-of-bound indices result in safe but unspecified behavior, which may include
-raising an error.
-
-<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-<img style="width:100%" src="https://www.tensorflow.org/images/Gather.png" alt>
-</div>
-END
-}
-op {
-  graph_op_name: "GatherNd"
-  endpoint {
-    name: "GatherNd"
-  }
-  summary: "Gather slices from `params` into a Tensor with shape specified by `indices`."
-  description: <<END
-`indices` is an K-dimensional integer tensor, best thought of as a
-(K-1)-dimensional tensor of indices into `params`, where each element defines a
-slice of `params`:
-
-    output[i_0, ..., i_{K-2}] = params[indices[i0, ..., i_{K-2}]]
-
-Whereas in @{tf.gather} `indices` defines slices into the first
-dimension of `params`, in `tf.gather_nd`, `indices` defines slices into the
-first `N` dimensions of `params`, where `N = indices.shape[-1]`.
-
-The last dimension of `indices` can be at most the rank of
-`params`:
-
-    indices.shape[-1] <= params.rank
-
-The last dimension of `indices` corresponds to elements
-(if `indices.shape[-1] == params.rank`) or slices
-(if `indices.shape[-1] < params.rank`) along dimension `indices.shape[-1]`
-of `params`.  The output tensor has shape
-
-    indices.shape[:-1] + params.shape[indices.shape[-1]:]
-
-Some examples below.
-
-Simple indexing into a matrix:
-
-```python
-    indices = [[0, 0], [1, 1]]
-    params = [['a', 'b'], ['c', 'd']]
-    output = ['a', 'd']
-```
-
-Slice indexing into a matrix:
-
-```python
-    indices = [[1], [0]]
-    params = [['a', 'b'], ['c', 'd']]
-    output = [['c', 'd'], ['a', 'b']]
-```
-
-Indexing into a 3-tensor:
-
-```python
-    indices = [[1]]
-    params = [[['a0', 'b0'], ['c0', 'd0']],
-              [['a1', 'b1'], ['c1', 'd1']]]
-    output = [[['a1', 'b1'], ['c1', 'd1']]]
-
-
-    indices = [[0, 1], [1, 0]]
-    params = [[['a0', 'b0'], ['c0', 'd0']],
-              [['a1', 'b1'], ['c1', 'd1']]]
-    output = [['c0', 'd0'], ['a1', 'b1']]
-
-
-    indices = [[0, 0, 1], [1, 0, 1]]
-    params = [[['a0', 'b0'], ['c0', 'd0']],
-              [['a1', 'b1'], ['c1', 'd1']]]
-    output = ['b0', 'b1']
-```
-
-Batched indexing into a matrix:
-
-```python
-    indices = [[[0, 0]], [[0, 1]]]
-    params = [['a', 'b'], ['c', 'd']]
-    output = [['a'], ['b']]
-```
-
-Batched slice indexing into a matrix:
-
-```python
-    indices = [[[1]], [[0]]]
-    params = [['a', 'b'], ['c', 'd']]
-    output = [[['c', 'd']], [['a', 'b']]]
-```
-
-Batched indexing into a 3-tensor:
-
-```python
-    indices = [[[1]], [[0]]]
-    params = [[['a0', 'b0'], ['c0', 'd0']],
-              [['a1', 'b1'], ['c1', 'd1']]]
-    output = [[[['a1', 'b1'], ['c1', 'd1']]],
-              [[['a0', 'b0'], ['c0', 'd0']]]]
-
-    indices = [[[0, 1], [1, 0]], [[0, 0], [1, 1]]]
-    params = [[['a0', 'b0'], ['c0', 'd0']],
-              [['a1', 'b1'], ['c1', 'd1']]]
-    output = [[['c0', 'd0'], ['a1', 'b1']],
-              [['a0', 'b0'], ['c1', 'd1']]]
-
-
-    indices = [[[0, 0, 1], [1, 0, 1]], [[0, 1, 1], [1, 1, 0]]]
-    params = [[['a0', 'b0'], ['c0', 'd0']],
-              [['a1', 'b1'], ['c1', 'd1']]]
-    output = [['b0', 'b1'], ['d0', 'c1']]
-```
-END
-}
-op {
-  graph_op_name: "GatherV2"
-  endpoint {
-    name: "GatherV2"
-  }
-  summary: "Gather slices from `params` axis `axis` according to `indices`."
-  description: <<END
-`indices` must be an integer tensor of any dimension (usually 0-D or 1-D).
-Produces an output tensor with shape `params.shape[:axis] + indices.shape +
-params.shape[axis + 1:]` where:
-
-```python
-    # Scalar indices (output is rank(params) - 1).
-    output[a_0, ..., a_n, b_0, ..., b_n] =
-      params[a_0, ..., a_n, indices, b_0, ..., b_n]
-
-    # Vector indices (output is rank(params)).
-    output[a_0, ..., a_n, i, b_0, ..., b_n] =
-      params[a_0, ..., a_n, indices[i], b_0, ..., b_n]
-
-    # Higher rank indices (output is rank(params) + rank(indices) - 1).
-    output[a_0, ..., a_n, i, ..., j, b_0, ... b_n] =
-      params[a_0, ..., a_n, indices[i, ..., j], b_0, ..., b_n]
-```
-
-<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-<img style="width:100%" src="https://www.tensorflow.org/images/Gather.png" alt>
-</div>
-END
-}
-op {
-  graph_op_name: "GenerateVocabRemapping"
-  endpoint {
-    name: "GenerateVocabRemapping"
-  }
-  summary: "Given a path to new and old vocabulary files, returns a remapping Tensor of"
-  description: <<END
-length `num_new_vocab`, where `remapping[i]` contains the row number in the old
-vocabulary that corresponds to row `i` in the new vocabulary (starting at line
-`new_vocab_offset` and up to `num_new_vocab` entities), or `-1` if entry `i`
-in the new vocabulary is not in the old vocabulary.  `num_vocab_offset` enables
-use in the partitioned variable case, and should generally be set through
-examining partitioning info.  The format of the files should be a text file,
-with each line containing a single entity within the vocabulary.
-
-For example, with `new_vocab_file` a text file containing each of the following
-elements on a single line: `[f0, f1, f2, f3]`, old_vocab_file = [f1, f0, f3],
-`num_new_vocab = 3, new_vocab_offset = 1`, the returned remapping would be
-`[0, -1, 2]`.
-
-The op also returns a count of how many entries in the new vocabulary
-were present in the old vocabulary, which is used to calculate the number of
-values to initialize in a weight matrix remapping
-
-This functionality can be used to remap both row vocabularies (typically,
-features) and column vocabularies (typically, classes) from TensorFlow
-checkpoints.  Note that the partitioning logic relies on contiguous vocabularies
-corresponding to div-partitioned variables.  Moreover, the underlying remapping
-uses an IndexTable (as opposed to an inexact CuckooTable), so client code should
-use the corresponding index_table_from_file() as the FeatureColumn framework
-does (as opposed to tf.feature_to_id(), which uses a CuckooTable).
-END
-}
-op {
-  graph_op_name: "GetSessionHandle"
-  endpoint {
-    name: "GetSessionHandle"
-  }
-  summary: "Store the input tensor in the state of the current session."
-}
-op {
-  graph_op_name: "GetSessionHandleV2"
-  endpoint {
-    name: "GetSessionHandleV2"
-  }
-  summary: "Store the input tensor in the state of the current session."
-}
-op {
-  graph_op_name: "GetSessionTensor"
-  endpoint {
-    name: "GetSessionTensor"
-  }
-  summary: "Get the value of the tensor specified by its handle."
-}
-op {
-  graph_op_name: "Greater"
-  endpoint {
-    name: "Greater"
-  }
-  summary: "Returns the truth value of (x > y) element-wise."
-  description: <<END
-*NOTE*: `Greater` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "GreaterEqual"
-  endpoint {
-    name: "GreaterEqual"
-  }
-  summary: "Returns the truth value of (x >= y) element-wise."
-  description: <<END
-*NOTE*: `GreaterEqual` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "GroupByWindowDataset"
-  endpoint {
-    name: "GroupByWindowDataset"
-  }
-  summary: "Creates a dataset that computes a windowed group-by on `input_dataset`."
-  description: <<END
-// TODO(mrry): Support non-int64 keys.
-END
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_Gather.pbtxt b/tensorflow/core/api_def/base_api/api_def_Gather.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6dcf2252ce6492e346ea2b3213a0f5075fcdfb25
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Gather.pbtxt
@@ -0,0 +1,31 @@
+op {
+  graph_op_name: "Gather"
+  summary: "Gather slices from `params` according to `indices`."
+  description: <<END
+`indices` must be an integer tensor of any dimension (usually 0-D or 1-D).
+Produces an output tensor with shape `indices.shape + params.shape[1:]` where:
+
+```python
+    # Scalar indices
+    output[:, ..., :] = params[indices, :, ... :]
+
+    # Vector indices
+    output[i, :, ..., :] = params[indices[i], :, ... :]
+
+    # Higher rank indices
+    output[i, ..., j, :, ... :] = params[indices[i, ..., j], :, ..., :]
+```
+
+If `indices` is a permutation and `len(indices) == params.shape[0]` then
+this operation will permute `params` accordingly.
+
+`validate_indices`: DEPRECATED. If this operation is assigned to CPU, values in
+`indices` are always validated to be within range. If assigned to GPU,
+out-of-bound indices result in safe but unspecified behavior, which may include
+raising an error.
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src="https://www.tensorflow.org/images/Gather.png" alt>
+</div>
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_GatherNd.pbtxt b/tensorflow/core/api_def/base_api/api_def_GatherNd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c7f8b6c21ba9fd85ee20c259425b04a8d4aade75
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_GatherNd.pbtxt
@@ -0,0 +1,123 @@
+op {
+  graph_op_name: "GatherNd"
+  in_arg {
+    name: "params"
+    description: <<END
+The tensor from which to gather values.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+Index tensor.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Values from `params` gathered from indices given by `indices`, with
+shape `indices.shape[:-1] + params.shape[indices.shape[-1]:]`.
+END
+  }
+  summary: "Gather slices from `params` into a Tensor with shape specified by `indices`."
+  description: <<END
+`indices` is an K-dimensional integer tensor, best thought of as a
+(K-1)-dimensional tensor of indices into `params`, where each element defines a
+slice of `params`:
+
+    output[i_0, ..., i_{K-2}] = params[indices[i0, ..., i_{K-2}]]
+
+Whereas in @{tf.gather} `indices` defines slices into the first
+dimension of `params`, in `tf.gather_nd`, `indices` defines slices into the
+first `N` dimensions of `params`, where `N = indices.shape[-1]`.
+
+The last dimension of `indices` can be at most the rank of
+`params`:
+
+    indices.shape[-1] <= params.rank
+
+The last dimension of `indices` corresponds to elements
+(if `indices.shape[-1] == params.rank`) or slices
+(if `indices.shape[-1] < params.rank`) along dimension `indices.shape[-1]`
+of `params`.  The output tensor has shape
+
+    indices.shape[:-1] + params.shape[indices.shape[-1]:]
+
+Some examples below.
+
+Simple indexing into a matrix:
+
+```python
+    indices = [[0, 0], [1, 1]]
+    params = [['a', 'b'], ['c', 'd']]
+    output = ['a', 'd']
+```
+
+Slice indexing into a matrix:
+
+```python
+    indices = [[1], [0]]
+    params = [['a', 'b'], ['c', 'd']]
+    output = [['c', 'd'], ['a', 'b']]
+```
+
+Indexing into a 3-tensor:
+
+```python
+    indices = [[1]]
+    params = [[['a0', 'b0'], ['c0', 'd0']],
+              [['a1', 'b1'], ['c1', 'd1']]]
+    output = [[['a1', 'b1'], ['c1', 'd1']]]
+
+
+    indices = [[0, 1], [1, 0]]
+    params = [[['a0', 'b0'], ['c0', 'd0']],
+              [['a1', 'b1'], ['c1', 'd1']]]
+    output = [['c0', 'd0'], ['a1', 'b1']]
+
+
+    indices = [[0, 0, 1], [1, 0, 1]]
+    params = [[['a0', 'b0'], ['c0', 'd0']],
+              [['a1', 'b1'], ['c1', 'd1']]]
+    output = ['b0', 'b1']
+```
+
+Batched indexing into a matrix:
+
+```python
+    indices = [[[0, 0]], [[0, 1]]]
+    params = [['a', 'b'], ['c', 'd']]
+    output = [['a'], ['b']]
+```
+
+Batched slice indexing into a matrix:
+
+```python
+    indices = [[[1]], [[0]]]
+    params = [['a', 'b'], ['c', 'd']]
+    output = [[['c', 'd']], [['a', 'b']]]
+```
+
+Batched indexing into a 3-tensor:
+
+```python
+    indices = [[[1]], [[0]]]
+    params = [[['a0', 'b0'], ['c0', 'd0']],
+              [['a1', 'b1'], ['c1', 'd1']]]
+    output = [[[['a1', 'b1'], ['c1', 'd1']]],
+              [[['a0', 'b0'], ['c0', 'd0']]]]
+
+    indices = [[[0, 1], [1, 0]], [[0, 0], [1, 1]]]
+    params = [[['a0', 'b0'], ['c0', 'd0']],
+              [['a1', 'b1'], ['c1', 'd1']]]
+    output = [[['c0', 'd0'], ['a1', 'b1']],
+              [['a0', 'b0'], ['c1', 'd1']]]
+
+
+    indices = [[[0, 0, 1], [1, 0, 1]], [[0, 1, 1], [1, 1, 0]]]
+    params = [[['a0', 'b0'], ['c0', 'd0']],
+              [['a1', 'b1'], ['c1', 'd1']]]
+    output = [['b0', 'b1'], ['d0', 'c1']]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_GatherV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_GatherV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c020176a3b41b257b54601aecab0d47d36849c81
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_GatherV2.pbtxt
@@ -0,0 +1,54 @@
+op {
+  graph_op_name: "GatherV2"
+  in_arg {
+    name: "params"
+    description: <<END
+The tensor from which to gather values. Must be at least rank
+`axis + 1`.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+Index tensor. Must be in range `[0, params.shape[axis])`.
+END
+  }
+  in_arg {
+    name: "axis"
+    description: <<END
+The axis in `params` to gather `indices` from. Defaults to the first
+dimension. Supports negative indexes.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Values from `params` gathered from indices given by `indices`, with
+shape `params.shape[:axis] + indices.shape + params.shape[axis + 1:]`.
+END
+  }
+  summary: "Gather slices from `params` axis `axis` according to `indices`."
+  description: <<END
+`indices` must be an integer tensor of any dimension (usually 0-D or 1-D).
+Produces an output tensor with shape `params.shape[:axis] + indices.shape +
+params.shape[axis + 1:]` where:
+
+```python
+    # Scalar indices (output is rank(params) - 1).
+    output[a_0, ..., a_n, b_0, ..., b_n] =
+      params[a_0, ..., a_n, indices, b_0, ..., b_n]
+
+    # Vector indices (output is rank(params)).
+    output[a_0, ..., a_n, i, b_0, ..., b_n] =
+      params[a_0, ..., a_n, indices[i], b_0, ..., b_n]
+
+    # Higher rank indices (output is rank(params) + rank(indices) - 1).
+    output[a_0, ..., a_n, i, ..., j, b_0, ... b_n] =
+      params[a_0, ..., a_n, indices[i, ..., j], b_0, ..., b_n]
+```
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src="https://www.tensorflow.org/images/Gather.png" alt>
+</div>
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_GenerateVocabRemapping.pbtxt b/tensorflow/core/api_def/base_api/api_def_GenerateVocabRemapping.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..085acf7ff18c3b638641a7fcf4dc421b98f7343d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_GenerateVocabRemapping.pbtxt
@@ -0,0 +1,68 @@
+op {
+  graph_op_name: "GenerateVocabRemapping"
+  in_arg {
+    name: "new_vocab_file"
+    description: <<END
+Path to the new vocab file.
+END
+  }
+  in_arg {
+    name: "old_vocab_file"
+    description: <<END
+Path to the old vocab file.
+END
+  }
+  out_arg {
+    name: "remapping"
+    description: <<END
+A Tensor of length num_new_vocab where the element at index i
+is equal to the old ID that maps to the new ID i.  This element is -1 for any
+new ID that is not found in the old vocabulary.
+END
+  }
+  out_arg {
+    name: "num_present"
+    description: <<END
+Number of new vocab entries found in old vocab.
+END
+  }
+  attr {
+    name: "new_vocab_offset"
+    description: <<END
+How many entries into the new vocab file to start reading.
+END
+  }
+  attr {
+    name: "num_new_vocab"
+    description: <<END
+Number of entries in the new vocab file to remap.
+END
+  }
+  summary: "Given a path to new and old vocabulary files, returns a remapping Tensor of"
+  description: <<END
+length `num_new_vocab`, where `remapping[i]` contains the row number in the old
+vocabulary that corresponds to row `i` in the new vocabulary (starting at line
+`new_vocab_offset` and up to `num_new_vocab` entities), or `-1` if entry `i`
+in the new vocabulary is not in the old vocabulary.  `num_vocab_offset` enables
+use in the partitioned variable case, and should generally be set through
+examining partitioning info.  The format of the files should be a text file,
+with each line containing a single entity within the vocabulary.
+
+For example, with `new_vocab_file` a text file containing each of the following
+elements on a single line: `[f0, f1, f2, f3]`, old_vocab_file = [f1, f0, f3],
+`num_new_vocab = 3, new_vocab_offset = 1`, the returned remapping would be
+`[0, -1, 2]`.
+
+The op also returns a count of how many entries in the new vocabulary
+were present in the old vocabulary, which is used to calculate the number of
+values to initialize in a weight matrix remapping
+
+This functionality can be used to remap both row vocabularies (typically,
+features) and column vocabularies (typically, classes) from TensorFlow
+checkpoints.  Note that the partitioning logic relies on contiguous vocabularies
+corresponding to div-partitioned variables.  Moreover, the underlying remapping
+uses an IndexTable (as opposed to an inexact CuckooTable), so client code should
+use the corresponding index_table_from_file() as the FeatureColumn framework
+does (as opposed to tf.feature_to_id(), which uses a CuckooTable).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_GetSessionHandle.pbtxt b/tensorflow/core/api_def/base_api/api_def_GetSessionHandle.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..243712c85315ed13c439a9ebe7e3f28da560f7fd
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_GetSessionHandle.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "GetSessionHandle"
+  in_arg {
+    name: "value"
+    description: <<END
+The tensor to be stored.
+END
+  }
+  out_arg {
+    name: "handle"
+    description: <<END
+The handle for the tensor stored in the session state, represented
+as a string.
+END
+  }
+  summary: "Store the input tensor in the state of the current session."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_GetSessionHandleV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_GetSessionHandleV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..63cdc053c749d0f8c4693499ddfd223509ca35c1
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_GetSessionHandleV2.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "GetSessionHandleV2"
+  in_arg {
+    name: "value"
+    description: <<END
+The tensor to be stored.
+END
+  }
+  out_arg {
+    name: "handle"
+    description: <<END
+The handle for the tensor stored in the session state, represented
+as a ResourceHandle object.
+END
+  }
+  summary: "Store the input tensor in the state of the current session."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_GetSessionTensor.pbtxt b/tensorflow/core/api_def/base_api/api_def_GetSessionTensor.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..89bd3efe22848a78b2b694a18e7807f529f224d3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_GetSessionTensor.pbtxt
@@ -0,0 +1,22 @@
+op {
+  graph_op_name: "GetSessionTensor"
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle for a tensor stored in the session state.
+END
+  }
+  out_arg {
+    name: "value"
+    description: <<END
+The tensor for the given handle.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of the output value.
+END
+  }
+  summary: "Get the value of the tensor specified by its handle."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Greater.pbtxt b/tensorflow/core/api_def/base_api/api_def_Greater.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4a4e2f2eddc2acdc67d16fae517332b0a0b5b852
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Greater.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "Greater"
+  summary: "Returns the truth value of (x > y) element-wise."
+  description: <<END
+*NOTE*: `Greater` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_GreaterEqual.pbtxt b/tensorflow/core/api_def/base_api/api_def_GreaterEqual.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..dc947f04886e49ad8656976b66a7c6796ae6b515
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_GreaterEqual.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "GreaterEqual"
+  summary: "Returns the truth value of (x >= y) element-wise."
+  description: <<END
+*NOTE*: `GreaterEqual` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_GroupByWindowDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_GroupByWindowDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ea6bcd469577d02e39afbeb2ba0c8b467e312ba9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_GroupByWindowDataset.pbtxt
@@ -0,0 +1,14 @@
+op {
+  graph_op_name: "GroupByWindowDataset"
+  attr {
+    name: "key_func"
+    description: <<END
+A function mapping an element of `input_dataset`, concatenated
+with `key_func_other_arguments` to a scalar value of type DT_INT64.
+END
+  }
+  summary: "Creates a dataset that computes a windowed group-by on `input_dataset`."
+  description: <<END
+// TODO(mrry): Support non-int64 keys.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_H.pbtxt b/tensorflow/core/api_def/base_api/api_def_H.pbtxt
deleted file mode 100644
index 71282e7defc91ef879433c4a5a25ebf6f256e629..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_H.pbtxt
+++ /dev/null
@@ -1,52 +0,0 @@
-op {
-  graph_op_name: "HSVToRGB"
-  endpoint {
-    name: "HSVToRGB"
-  }
-  summary: "Convert one or more images from HSV to RGB."
-  description: <<END
-Outputs a tensor of the same shape as the `images` tensor, containing the RGB
-value of the pixels. The output is only well defined if the value in `images`
-are in `[0,1]`.
-
-See `rgb_to_hsv` for a description of the HSV encoding.
-END
-}
-op {
-  graph_op_name: "HashTable"
-  endpoint {
-    name: "HashTable"
-  }
-  summary: "Creates a non-initialized hash table."
-  description: <<END
-This op creates a hash table, specifying the type of its keys and values.
-Before using the table you will have to initialize it.  After initialization the
-table will be immutable.
-END
-}
-op {
-  graph_op_name: "HashTableV2"
-  endpoint {
-    name: "HashTableV2"
-  }
-  summary: "Creates a non-initialized hash table."
-  description: <<END
-This op creates a hash table, specifying the type of its keys and values.
-Before using the table you will have to initialize it.  After initialization the
-table will be immutable.
-END
-}
-op {
-  graph_op_name: "HistogramSummary"
-  endpoint {
-    name: "HistogramSummary"
-  }
-  summary: "Outputs a `Summary` protocol buffer with a histogram."
-  description: <<END
-The generated
-[`Summary`](https://www.tensorflow.org/code/tensorflow/core/framework/summary.proto)
-has one summary value containing a histogram for `values`.
-
-This op reports an `InvalidArgument` error if any value is not finite.
-END
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_HSVToRGB.pbtxt b/tensorflow/core/api_def/base_api/api_def_HSVToRGB.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5b23ef3c414612e3c92c1fe3195ea32da433bf39
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_HSVToRGB.pbtxt
@@ -0,0 +1,23 @@
+op {
+  graph_op_name: "HSVToRGB"
+  in_arg {
+    name: "images"
+    description: <<END
+1-D or higher rank. HSV data to convert. Last dimension must be size 3.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+`images` converted to RGB.
+END
+  }
+  summary: "Convert one or more images from HSV to RGB."
+  description: <<END
+Outputs a tensor of the same shape as the `images` tensor, containing the RGB
+value of the pixels. The output is only well defined if the value in `images`
+are in `[0,1]`.
+
+See `rgb_to_hsv` for a description of the HSV encoding.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_HashTable.pbtxt b/tensorflow/core/api_def/base_api/api_def_HashTable.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bb20232a8990050e91ab5656c28a15ccbd1cccd8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_HashTable.pbtxt
@@ -0,0 +1,49 @@
+op {
+  graph_op_name: "HashTable"
+  visibility: SKIP
+  out_arg {
+    name: "table_handle"
+    description: <<END
+Handle to a table.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this table is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this table is shared under the given name across
+multiple sessions.
+END
+  }
+  attr {
+    name: "use_node_name_sharing"
+    description: <<END
+If true and shared_name is empty, the table is shared
+using the node name.
+END
+  }
+  attr {
+    name: "key_dtype"
+    description: <<END
+Type of the table keys.
+END
+  }
+  attr {
+    name: "value_dtype"
+    description: <<END
+Type of the table values.
+END
+  }
+  summary: "Creates a non-initialized hash table."
+  description: <<END
+This op creates a hash table, specifying the type of its keys and values.
+Before using the table you will have to initialize it.  After initialization the
+table will be immutable.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_HashTableV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_HashTableV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..eddd4e256c93ddfd91f83c4149088fe586f2f377
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_HashTableV2.pbtxt
@@ -0,0 +1,51 @@
+op {
+  graph_op_name: "HashTableV2"
+  endpoint {
+    name: "HashTable"
+  }
+  out_arg {
+    name: "table_handle"
+    description: <<END
+Handle to a table.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this table is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this table is shared under the given name across
+multiple sessions.
+END
+  }
+  attr {
+    name: "use_node_name_sharing"
+    description: <<END
+If true and shared_name is empty, the table is shared
+using the node name.
+END
+  }
+  attr {
+    name: "key_dtype"
+    description: <<END
+Type of the table keys.
+END
+  }
+  attr {
+    name: "value_dtype"
+    description: <<END
+Type of the table values.
+END
+  }
+  summary: "Creates a non-initialized hash table."
+  description: <<END
+This op creates a hash table, specifying the type of its keys and values.
+Before using the table you will have to initialize it.  After initialization the
+table will be immutable.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_HistogramFixedWidth.pbtxt b/tensorflow/core/api_def/base_api/api_def_HistogramFixedWidth.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9b7fcd67f1324888f82015441add7a655b90d5e7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_HistogramFixedWidth.pbtxt
@@ -0,0 +1,47 @@
+op {
+  graph_op_name: "HistogramFixedWidth"
+  in_arg {
+    name: "values"
+    description: <<END
+Numeric `Tensor`.
+END
+  }
+  in_arg {
+    name: "value_range"
+    description: <<END
+Shape [2] `Tensor` of same `dtype` as `values`.
+values <= value_range[0] will be mapped to hist[0],
+values >= value_range[1] will be mapped to hist[-1].
+END
+  }
+  in_arg {
+    name: "nbins"
+    description: <<END
+Scalar `int32 Tensor`.  Number of histogram bins.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+A 1-D `Tensor` holding histogram of values.
+END
+  }
+  summary: "Return histogram of values."
+  description: <<END
+Given the tensor `values`, this operation returns a rank 1 histogram counting
+the number of entries in `values` that fall into every bin.  The bins are
+equal width and determined by the arguments `value_range` and `nbins`.
+
+```python
+# Bins will be:  (-inf, 1), [1, 2), [2, 3), [3, 4), [4, inf)
+nbins = 5
+value_range = [0.0, 5.0]
+new_values = [-1.0, 0.0, 1.5, 2.0, 5.0, 15]
+
+with tf.get_default_session() as sess:
+  hist = tf.histogram_fixed_width(new_values, value_range, nbins=5)
+  variables.global_variables_initializer().run()
+  sess.run(hist) => [2, 1, 1, 0, 2]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_HistogramSummary.pbtxt b/tensorflow/core/api_def/base_api/api_def_HistogramSummary.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..faf1ed5abdd151222d07bc4b15f287ee9620cdb1
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_HistogramSummary.pbtxt
@@ -0,0 +1,29 @@
+op {
+  graph_op_name: "HistogramSummary"
+  in_arg {
+    name: "tag"
+    description: <<END
+Scalar.  Tag to use for the `Summary.Value`.
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+Any shape. Values to use to build the histogram.
+END
+  }
+  out_arg {
+    name: "summary"
+    description: <<END
+Scalar. Serialized `Summary` protocol buffer.
+END
+  }
+  summary: "Outputs a `Summary` protocol buffer with a histogram."
+  description: <<END
+The generated
+[`Summary`](https://www.tensorflow.org/code/tensorflow/core/framework/summary.proto)
+has one summary value containing a histogram for `values`.
+
+This op reports an `InvalidArgument` error if any value is not finite.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_I.pbtxt b/tensorflow/core/api_def/base_api/api_def_I.pbtxt
deleted file mode 100644
index caaf93bf883c9e81d0199562b87533c29e8e8488..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_I.pbtxt
+++ /dev/null
@@ -1,518 +0,0 @@
-op {
-  graph_op_name: "IFFT"
-  endpoint {
-    name: "IFFT"
-  }
-  summary: "Inverse fast Fourier transform."
-  description: <<END
-Computes the inverse 1-dimensional discrete Fourier transform over the
-inner-most dimension of `input`.
-END
-}
-op {
-  graph_op_name: "IFFT2D"
-  endpoint {
-    name: "IFFT2D"
-  }
-  summary: "Inverse 2D fast Fourier transform."
-  description: <<END
-Computes the inverse 2-dimensional discrete Fourier transform over the
-inner-most 2 dimensions of `input`.
-END
-}
-op {
-  graph_op_name: "IFFT3D"
-  endpoint {
-    name: "IFFT3D"
-  }
-  summary: "Inverse 3D fast Fourier transform."
-  description: <<END
-Computes the inverse 3-dimensional discrete Fourier transform over the
-inner-most 3 dimensions of `input`.
-END
-}
-op {
-  graph_op_name: "IRFFT"
-  endpoint {
-    name: "IRFFT"
-  }
-  summary: "Inverse real-valued fast Fourier transform."
-  description: <<END
-Computes the inverse 1-dimensional discrete Fourier transform of a real-valued
-signal over the inner-most dimension of `input`.
-
-The inner-most dimension of `input` is assumed to be the result of `RFFT`: the
-`fft_length / 2 + 1` unique components of the DFT of a real-valued signal. If
-`fft_length` is not provided, it is computed from the size of the inner-most
-dimension of `input` (`fft_length = 2 * (inner - 1)`). If the FFT length used to
-compute `input` is odd, it should be provided since it cannot be inferred
-properly.
-
-Along the axis `IRFFT` is computed on, if `fft_length / 2 + 1` is smaller
-than the corresponding dimension of `input`, the dimension is cropped. If it is
-larger, the dimension is padded with zeros.
-END
-}
-op {
-  graph_op_name: "IRFFT2D"
-  endpoint {
-    name: "IRFFT2D"
-  }
-  summary: "Inverse 2D real-valued fast Fourier transform."
-  description: <<END
-Computes the inverse 2-dimensional discrete Fourier transform of a real-valued
-signal over the inner-most 2 dimensions of `input`.
-
-The inner-most 2 dimensions of `input` are assumed to be the result of `RFFT2D`:
-The inner-most dimension contains the `fft_length / 2 + 1` unique components of
-the DFT of a real-valued signal. If `fft_length` is not provided, it is computed
-from the size of the inner-most 2 dimensions of `input`. If the FFT length used
-to compute `input` is odd, it should be provided since it cannot be inferred
-properly.
-
-Along each axis `IRFFT2D` is computed on, if `fft_length` (or
-`fft_length / 2 + 1` for the inner-most dimension) is smaller than the
-corresponding dimension of `input`, the dimension is cropped. If it is larger,
-the dimension is padded with zeros.
-END
-}
-op {
-  graph_op_name: "IRFFT3D"
-  endpoint {
-    name: "IRFFT3D"
-  }
-  summary: "Inverse 3D real-valued fast Fourier transform."
-  description: <<END
-Computes the inverse 3-dimensional discrete Fourier transform of a real-valued
-signal over the inner-most 3 dimensions of `input`.
-
-The inner-most 3 dimensions of `input` are assumed to be the result of `RFFT3D`:
-The inner-most dimension contains the `fft_length / 2 + 1` unique components of
-the DFT of a real-valued signal. If `fft_length` is not provided, it is computed
-from the size of the inner-most 3 dimensions of `input`. If the FFT length used
-to compute `input` is odd, it should be provided since it cannot be inferred
-properly.
-
-Along each axis `IRFFT3D` is computed on, if `fft_length` (or
-`fft_length / 2 + 1` for the inner-most dimension) is smaller than the
-corresponding dimension of `input`, the dimension is cropped. If it is larger,
-the dimension is padded with zeros.
-END
-}
-op {
-  graph_op_name: "Identity"
-  endpoint {
-    name: "Identity"
-  }
-  summary: "Return a tensor with the same shape and contents as the input tensor or value."
-}
-op {
-  graph_op_name: "IdentityN"
-  endpoint {
-    name: "IdentityN"
-  }
-  summary: "Returns a list of tensors with the same shapes and contents as the input"
-  description: <<END
-tensors.
-
-This op can be used to override the gradient for complicated functions. For
-example, suppose y = f(x) and we wish to apply a custom function g for backprop
-such that dx = g(dy). In Python,
-
-```python
-with tf.get_default_graph().gradient_override_map(
-    {'IdentityN': 'OverrideGradientWithG'}):
-  y, _ = identity_n([f(x), x])
-
-@tf.RegisterGradient('OverrideGradientWithG')
-def ApplyG(op, dy, _):
-  return [None, g(dy)]  # Do not backprop to f(x).
-```
-END
-}
-op {
-  graph_op_name: "IdentityReader"
-  endpoint {
-    name: "IdentityReader"
-  }
-  summary: "A Reader that outputs the queued work as both the key and value."
-  description: <<END
-To use, enqueue strings in a Queue.  ReaderRead will take the front
-work string and output (work, work).
-END
-}
-op {
-  graph_op_name: "IdentityReaderV2"
-  endpoint {
-    name: "IdentityReaderV2"
-  }
-  summary: "A Reader that outputs the queued work as both the key and value."
-  description: <<END
-To use, enqueue strings in a Queue.  ReaderRead will take the front
-work string and output (work, work).
-END
-}
-op {
-  graph_op_name: "Igamma"
-  endpoint {
-    name: "Igamma"
-  }
-  summary: "Compute the lower regularized incomplete Gamma function `Q(a, x)`."
-  description: <<END
-The lower regularized incomplete Gamma function is defined as:
-
-
-\\(P(a, x) = gamma(a, x) / Gamma(a) = 1 - Q(a, x)\\)
-
-where
-
-\\(gamma(a, x) = int_{0}^{x} t^{a-1} exp(-t) dt\\)
-
-is the lower incomplete Gamma function.
-
-Note, above `Q(a, x)` (`Igammac`) is the upper regularized complete
-Gamma function.
-END
-}
-op {
-  graph_op_name: "Igammac"
-  endpoint {
-    name: "Igammac"
-  }
-  summary: "Compute the upper regularized incomplete Gamma function `Q(a, x)`."
-  description: <<END
-The upper regularized incomplete Gamma function is defined as:
-
-\\(Q(a, x) = Gamma(a, x) / Gamma(a) = 1 - P(a, x)\\)
-
-where
-
-\\(Gamma(a, x) = int_{x}^{\infty} t^{a-1} exp(-t) dt\\)
-
-is the upper incomplete Gama function.
-
-Note, above `P(a, x)` (`Igamma`) is the lower regularized complete
-Gamma function.
-END
-}
-op {
-  graph_op_name: "IgnoreErrorsDataset"
-  endpoint {
-    name: "IgnoreErrorsDataset"
-  }
-  summary: "Creates a dataset that contains the elements of `input_dataset` ignoring errors."
-}
-op {
-  graph_op_name: "Imag"
-  endpoint {
-    name: "Imag"
-  }
-  summary: "Returns the imaginary part of a complex number."
-  description: <<END
-Given a tensor `input` of complex numbers, this operation returns a tensor of
-type `float` that is the imaginary part of each element in `input`. All
-elements in `input` must be complex numbers of the form \\(a + bj\\), where *a*
-is the real part and *b* is the imaginary part returned by this operation.
-
-For example:
-
-```
-# tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
-tf.imag(input) ==> [4.75, 5.75]
-```
-END
-}
-op {
-  graph_op_name: "ImageSummary"
-  endpoint {
-    name: "ImageSummary"
-  }
-  summary: "Outputs a `Summary` protocol buffer with images."
-  description: <<END
-The summary has up to `max_images` summary values containing images. The
-images are built from `tensor` which must be 4-D with shape `[batch_size,
-height, width, channels]` and where `channels` can be:
-
-*  1: `tensor` is interpreted as Grayscale.
-*  3: `tensor` is interpreted as RGB.
-*  4: `tensor` is interpreted as RGBA.
-
-The images have the same number of channels as the input tensor. For float
-input, the values are normalized one image at a time to fit in the range
-`[0, 255]`.  `uint8` values are unchanged.  The op uses two different
-normalization algorithms:
-
-*  If the input values are all positive, they are rescaled so the largest one
-   is 255.
-
-*  If any input value is negative, the values are shifted so input value 0.0
-   is at 127.  They are then rescaled so that either the smallest value is 0,
-   or the largest one is 255.
-
-The `tag` argument is a scalar `Tensor` of type `string`.  It is used to
-build the `tag` of the summary values:
-
-*  If `max_images` is 1, the summary value tag is '*tag*/image'.
-*  If `max_images` is greater than 1, the summary value tags are
-   generated sequentially as '*tag*/image/0', '*tag*/image/1', etc.
-
-The `bad_color` argument is the color to use in the generated images for
-non-finite input values.  It is a `unit8` 1-D tensor of length `channels`.
-Each element must be in the range `[0, 255]` (It represents the value of a
-pixel in the output image).  Non-finite values in the input tensor are
-replaced by this tensor in the output image.  The default value is the color
-red.
-END
-}
-op {
-  graph_op_name: "ImmutableConst"
-  endpoint {
-    name: "ImmutableConst"
-  }
-  summary: "Returns immutable tensor from memory region."
-  description: <<END
-The current implementation memmaps the tensor from a file.
-END
-}
-op {
-  graph_op_name: "InTopK"
-  endpoint {
-    name: "InTopK"
-  }
-  summary: "Says whether the targets are in the top `K` predictions."
-  description: <<END
-This outputs a `batch_size` bool array, an entry `out[i]` is `true` if the
-prediction for the target class is among the top `k` predictions among
-all predictions for example `i`. Note that the behavior of `InTopK` differs
-from the `TopK` op in its handling of ties; if multiple classes have the
-same prediction value and straddle the top-`k` boundary, all of those
-classes are considered to be in the top `k`.
-
-More formally, let
-
-  \\(predictions_i\\) be the predictions for all classes for example `i`,
-  \\(targets_i\\) be the target class for example `i`,
-  \\(out_i\\) be the output for example `i`,
-
-$$out_i = predictions_{i, targets_i} \in TopKIncludingTies(predictions_i)$$
-END
-}
-op {
-  graph_op_name: "InTopKV2"
-  endpoint {
-    name: "InTopKV2"
-  }
-  summary: "Says whether the targets are in the top `K` predictions."
-  description: <<END
-This outputs a `batch_size` bool array, an entry `out[i]` is `true` if the
-prediction for the target class is among the top `k` predictions among
-all predictions for example `i`. Note that the behavior of `InTopK` differs
-from the `TopK` op in its handling of ties; if multiple classes have the
-same prediction value and straddle the top-`k` boundary, all of those
-classes are considered to be in the top `k`.
-
-More formally, let
-
-  \\(predictions_i\\) be the predictions for all classes for example `i`,
-  \\(targets_i\\) be the target class for example `i`,
-  \\(out_i\\) be the output for example `i`,
-
-$$out_i = predictions_{i, targets_i} \in TopKIncludingTies(predictions_i)$$
-END
-}
-op {
-  graph_op_name: "InitializeTable"
-  endpoint {
-    name: "InitializeTable"
-  }
-  summary: "Table initializer that takes two tensors for keys and values respectively."
-}
-op {
-  graph_op_name: "InitializeTableFromTextFile"
-  endpoint {
-    name: "InitializeTableFromTextFile"
-  }
-  summary: "Initializes a table from a text file."
-  description: <<END
-It inserts one key-value pair into the table for each line of the file.
-The key and value is extracted from the whole line content, elements from the
-split line based on `delimiter` or the line number (starting from zero).
-Where to extract the key and value from a line is specified by `key_index` and
-`value_index`.
-
-- A value of -1 means use the line number(starting from zero), expects `int64`.
-- A value of -2 means use the whole line content, expects `string`.
-- A value >= 0 means use the index (starting at zero) of the split line based
-  on `delimiter`.
-END
-}
-op {
-  graph_op_name: "InitializeTableFromTextFileV2"
-  endpoint {
-    name: "InitializeTableFromTextFileV2"
-  }
-  summary: "Initializes a table from a text file."
-  description: <<END
-It inserts one key-value pair into the table for each line of the file.
-The key and value is extracted from the whole line content, elements from the
-split line based on `delimiter` or the line number (starting from zero).
-Where to extract the key and value from a line is specified by `key_index` and
-`value_index`.
-
-- A value of -1 means use the line number(starting from zero), expects `int64`.
-- A value of -2 means use the whole line content, expects `string`.
-- A value >= 0 means use the index (starting at zero) of the split line based
-  on `delimiter`.
-END
-}
-op {
-  graph_op_name: "InitializeTableV2"
-  endpoint {
-    name: "InitializeTableV2"
-  }
-  summary: "Table initializer that takes two tensors for keys and values respectively."
-}
-op {
-  graph_op_name: "InterleaveDataset"
-  endpoint {
-    name: "InterleaveDataset"
-  }
-  summary: "Creates a dataset that applies `f` to the outputs of `input_dataset`."
-  description: <<END
-Unlike MapDataset, the `f` in InterleaveDataset is expected to return
-a Dataset variant, and InterleaveDataset will flatten successive
-results into a single Dataset. Unlike FlatMapDataset,
-InterleaveDataset will interleave sequences of up to `block_length`
-consecutive elements from `cycle_length` input elements.
-END
-}
-op {
-  graph_op_name: "Inv"
-  endpoint {
-    name: "Inv"
-  }
-  summary: "Computes the reciprocal of x element-wise."
-  description: <<END
-I.e., \\(y = 1 / x\\).
-END
-}
-op {
-  graph_op_name: "InvGrad"
-  endpoint {
-    name: "InvGrad"
-  }
-  summary: "Computes the gradient for the inverse of `x` wrt its input."
-  description: <<END
-Specifically, `grad = -dy * y*y`, where `y = 1/x`, and `dy`
-is the corresponding input gradient.
-END
-}
-op {
-  graph_op_name: "Invert"
-  endpoint {
-    name: "Invert"
-  }
-  summary: "Flips all bits elementwise."
-  description: <<END
-The result will have exactly those bits set, that are not set in `x`. The
-computation is performed on the underlying representation of x.
-END
-}
-op {
-  graph_op_name: "InvertPermutation"
-  endpoint {
-    name: "InvertPermutation"
-  }
-  summary: "Computes the inverse permutation of a tensor."
-  description: <<END
-This operation computes the inverse of an index permutation. It takes a 1-D
-integer tensor `x`, which represents the indices of a zero-based array, and
-swaps each value with its index position. In other words, for an output tensor
-`y` and an input tensor `x`, this operation computes the following:
-
-`y[x[i]] = i for i in [0, 1, ..., len(x) - 1]`
-
-The values must include 0. There can be no duplicate values or negative values.
-
-For example:
-
-```
-# tensor `x` is [3, 4, 0, 2, 1]
-invert_permutation(x) ==> [2, 4, 3, 0, 1]
-```
-END
-}
-op {
-  graph_op_name: "IsFinite"
-  endpoint {
-    name: "IsFinite"
-  }
-  summary: "Returns which elements of x are finite."
-  description: <<END
-@compatibility(numpy)
-Equivalent to np.isfinite
-@end_compatibility
-END
-}
-op {
-  graph_op_name: "IsInf"
-  endpoint {
-    name: "IsInf"
-  }
-  summary: "Returns which elements of x are Inf."
-  description: <<END
-@compatibility(numpy)
-Equivalent to np.isinf
-@end_compatibility
-END
-}
-op {
-  graph_op_name: "IsNan"
-  endpoint {
-    name: "IsNan"
-  }
-  summary: "Returns which elements of x are NaN."
-  description: <<END
-@compatibility(numpy)
-Equivalent to np.isnan
-@end_compatibility
-END
-}
-op {
-  graph_op_name: "IsVariableInitialized"
-  endpoint {
-    name: "IsVariableInitialized"
-  }
-  summary: "Checks whether a tensor has been initialized."
-  description: <<END
-Outputs boolean scalar indicating whether the tensor has been initialized.
-END
-}
-op {
-  graph_op_name: "Iterator"
-  endpoint {
-    name: "Iterator"
-  }
-  summary: "A container for an iterator resource."
-}
-op {
-  graph_op_name: "IteratorFromStringHandle"
-  endpoint {
-    name: "IteratorFromStringHandle"
-  }
-  summary: "Converts the given string representing a handle to an iterator to a resource."
-}
-op {
-  graph_op_name: "IteratorGetNext"
-  endpoint {
-    name: "IteratorGetNext"
-  }
-  summary: "Gets the next output from the given iterator."
-}
-op {
-  graph_op_name: "IteratorToStringHandle"
-  endpoint {
-    name: "IteratorToStringHandle"
-  }
-  summary: "Converts the given `resource_handle` representing an iterator to a string."
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_IFFT.pbtxt b/tensorflow/core/api_def/base_api/api_def_IFFT.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b793c99cf74408305b48dbbf1c9df7b03d09b2f3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_IFFT.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "IFFT"
+  in_arg {
+    name: "input"
+    description: <<END
+A complex64 tensor.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A complex64 tensor of the same shape as `input`. The inner-most
+  dimension of `input` is replaced with its inverse 1D Fourier transform.
+
+@compatibility(numpy)
+Equivalent to np.fft.ifft
+@end_compatibility
+END
+  }
+  summary: "Inverse fast Fourier transform."
+  description: <<END
+Computes the inverse 1-dimensional discrete Fourier transform over the
+inner-most dimension of `input`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_IFFT2D.pbtxt b/tensorflow/core/api_def/base_api/api_def_IFFT2D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7f38f14308de70fb0ebc229064d010762055c458
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_IFFT2D.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "IFFT2D"
+  in_arg {
+    name: "input"
+    description: <<END
+A complex64 tensor.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A complex64 tensor of the same shape as `input`. The inner-most 2
+  dimensions of `input` are replaced with their inverse 2D Fourier transform.
+
+@compatibility(numpy)
+Equivalent to np.fft.ifft2
+@end_compatibility
+END
+  }
+  summary: "Inverse 2D fast Fourier transform."
+  description: <<END
+Computes the inverse 2-dimensional discrete Fourier transform over the
+inner-most 2 dimensions of `input`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_IFFT3D.pbtxt b/tensorflow/core/api_def/base_api/api_def_IFFT3D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..52f1118775b16820f5e1bf6f0f9d934219b10f9d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_IFFT3D.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "IFFT3D"
+  in_arg {
+    name: "input"
+    description: <<END
+A complex64 tensor.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A complex64 tensor of the same shape as `input`. The inner-most 3
+  dimensions of `input` are replaced with their inverse 3D Fourier transform.
+
+@compatibility(numpy)
+Equivalent to np.fft.ifftn with 3 dimensions.
+@end_compatibility
+END
+  }
+  summary: "Inverse 3D fast Fourier transform."
+  description: <<END
+Computes the inverse 3-dimensional discrete Fourier transform over the
+inner-most 3 dimensions of `input`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_IRFFT.pbtxt b/tensorflow/core/api_def/base_api/api_def_IRFFT.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1e1caa9eade5480cd95ac7da0ce66cdcbcbef662
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_IRFFT.pbtxt
@@ -0,0 +1,43 @@
+op {
+  graph_op_name: "IRFFT"
+  in_arg {
+    name: "input"
+    description: <<END
+A complex64 tensor.
+END
+  }
+  in_arg {
+    name: "fft_length"
+    description: <<END
+An int32 tensor of shape [1]. The FFT length.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A float32 tensor of the same rank as `input`. The inner-most
+  dimension of `input` is replaced with the `fft_length` samples of its inverse
+  1D Fourier transform.
+
+@compatibility(numpy)
+Equivalent to np.fft.irfft
+@end_compatibility
+END
+  }
+  summary: "Inverse real-valued fast Fourier transform."
+  description: <<END
+Computes the inverse 1-dimensional discrete Fourier transform of a real-valued
+signal over the inner-most dimension of `input`.
+
+The inner-most dimension of `input` is assumed to be the result of `RFFT`: the
+`fft_length / 2 + 1` unique components of the DFT of a real-valued signal. If
+`fft_length` is not provided, it is computed from the size of the inner-most
+dimension of `input` (`fft_length = 2 * (inner - 1)`). If the FFT length used to
+compute `input` is odd, it should be provided since it cannot be inferred
+properly.
+
+Along the axis `IRFFT` is computed on, if `fft_length / 2 + 1` is smaller
+than the corresponding dimension of `input`, the dimension is cropped. If it is
+larger, the dimension is padded with zeros.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_IRFFT2D.pbtxt b/tensorflow/core/api_def/base_api/api_def_IRFFT2D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9b7390a38577c1a3e35a43c0814c0a5bdb8ecab9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_IRFFT2D.pbtxt
@@ -0,0 +1,44 @@
+op {
+  graph_op_name: "IRFFT2D"
+  in_arg {
+    name: "input"
+    description: <<END
+A complex64 tensor.
+END
+  }
+  in_arg {
+    name: "fft_length"
+    description: <<END
+An int32 tensor of shape [2]. The FFT length for each dimension.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A float32 tensor of the same rank as `input`. The inner-most 2
+  dimensions of `input` are replaced with the `fft_length` samples of their
+  inverse 2D Fourier transform.
+
+@compatibility(numpy)
+Equivalent to np.fft.irfft2
+@end_compatibility
+END
+  }
+  summary: "Inverse 2D real-valued fast Fourier transform."
+  description: <<END
+Computes the inverse 2-dimensional discrete Fourier transform of a real-valued
+signal over the inner-most 2 dimensions of `input`.
+
+The inner-most 2 dimensions of `input` are assumed to be the result of `RFFT2D`:
+The inner-most dimension contains the `fft_length / 2 + 1` unique components of
+the DFT of a real-valued signal. If `fft_length` is not provided, it is computed
+from the size of the inner-most 2 dimensions of `input`. If the FFT length used
+to compute `input` is odd, it should be provided since it cannot be inferred
+properly.
+
+Along each axis `IRFFT2D` is computed on, if `fft_length` (or
+`fft_length / 2 + 1` for the inner-most dimension) is smaller than the
+corresponding dimension of `input`, the dimension is cropped. If it is larger,
+the dimension is padded with zeros.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_IRFFT3D.pbtxt b/tensorflow/core/api_def/base_api/api_def_IRFFT3D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1cee2ceeff054a4bd72855e53fafbce941f9e4e0
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_IRFFT3D.pbtxt
@@ -0,0 +1,44 @@
+op {
+  graph_op_name: "IRFFT3D"
+  in_arg {
+    name: "input"
+    description: <<END
+A complex64 tensor.
+END
+  }
+  in_arg {
+    name: "fft_length"
+    description: <<END
+An int32 tensor of shape [3]. The FFT length for each dimension.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A float32 tensor of the same rank as `input`. The inner-most 3
+  dimensions of `input` are replaced with the `fft_length` samples of their
+  inverse 3D real Fourier transform.
+
+@compatibility(numpy)
+Equivalent to np.irfftn with 3 dimensions.
+@end_compatibility
+END
+  }
+  summary: "Inverse 3D real-valued fast Fourier transform."
+  description: <<END
+Computes the inverse 3-dimensional discrete Fourier transform of a real-valued
+signal over the inner-most 3 dimensions of `input`.
+
+The inner-most 3 dimensions of `input` are assumed to be the result of `RFFT3D`:
+The inner-most dimension contains the `fft_length / 2 + 1` unique components of
+the DFT of a real-valued signal. If `fft_length` is not provided, it is computed
+from the size of the inner-most 3 dimensions of `input`. If the FFT length used
+to compute `input` is odd, it should be provided since it cannot be inferred
+properly.
+
+Along each axis `IRFFT3D` is computed on, if `fft_length` (or
+`fft_length / 2 + 1` for the inner-most dimension) is smaller than the
+corresponding dimension of `input`, the dimension is cropped. If it is larger,
+the dimension is padded with zeros.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Identity.pbtxt b/tensorflow/core/api_def/base_api/api_def_Identity.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a2eb82e890f97cef8c82586bab6643eb0737c295
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Identity.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Identity"
+  summary: "Return a tensor with the same shape and contents as the input tensor or value."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_IdentityN.pbtxt b/tensorflow/core/api_def/base_api/api_def_IdentityN.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..45c213bce1eebdef26e194d82155e1a8d7624c22
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_IdentityN.pbtxt
@@ -0,0 +1,21 @@
+op {
+  graph_op_name: "IdentityN"
+  summary: "Returns a list of tensors with the same shapes and contents as the input"
+  description: <<END
+tensors.
+
+This op can be used to override the gradient for complicated functions. For
+example, suppose y = f(x) and we wish to apply a custom function g for backprop
+such that dx = g(dy). In Python,
+
+```python
+with tf.get_default_graph().gradient_override_map(
+    {'IdentityN': 'OverrideGradientWithG'}):
+  y, _ = identity_n([f(x), x])
+
+@tf.RegisterGradient('OverrideGradientWithG')
+def ApplyG(op, dy, _):
+  return [None, g(dy)]  # Do not backprop to f(x).
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_IdentityReader.pbtxt b/tensorflow/core/api_def/base_api/api_def_IdentityReader.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9747d5c18cdbd98d3c112c048889533040b12553
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_IdentityReader.pbtxt
@@ -0,0 +1,29 @@
+op {
+  graph_op_name: "IdentityReader"
+  visibility: SKIP
+  out_arg {
+    name: "reader_handle"
+    description: <<END
+The handle to reference the Reader.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this reader is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this reader is named in the given bucket
+with this shared_name. Otherwise, the node name is used instead.
+END
+  }
+  summary: "A Reader that outputs the queued work as both the key and value."
+  description: <<END
+To use, enqueue strings in a Queue.  ReaderRead will take the front
+work string and output (work, work).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_IdentityReaderV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_IdentityReaderV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..71ef0115994aaa041acbc56efe3bee214f56d65c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_IdentityReaderV2.pbtxt
@@ -0,0 +1,31 @@
+op {
+  graph_op_name: "IdentityReaderV2"
+  endpoint {
+    name: "IdentityReader"
+  }
+  out_arg {
+    name: "reader_handle"
+    description: <<END
+The handle to reference the Reader.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this reader is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this reader is named in the given bucket
+with this shared_name. Otherwise, the node name is used instead.
+END
+  }
+  summary: "A Reader that outputs the queued work as both the key and value."
+  description: <<END
+To use, enqueue strings in a Queue.  ReaderRead will take the front
+work string and output (work, work).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Igamma.pbtxt b/tensorflow/core/api_def/base_api/api_def_Igamma.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e7bc5ddae237deb226606dc96141845e3efcc859
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Igamma.pbtxt
@@ -0,0 +1,19 @@
+op {
+  graph_op_name: "Igamma"
+  summary: "Compute the lower regularized incomplete Gamma function `Q(a, x)`."
+  description: <<END
+The lower regularized incomplete Gamma function is defined as:
+
+
+\\(P(a, x) = gamma(a, x) / Gamma(a) = 1 - Q(a, x)\\)
+
+where
+
+\\(gamma(a, x) = int_{0}^{x} t^{a-1} exp(-t) dt\\)
+
+is the lower incomplete Gamma function.
+
+Note, above `Q(a, x)` (`Igammac`) is the upper regularized complete
+Gamma function.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Igammac.pbtxt b/tensorflow/core/api_def/base_api/api_def_Igammac.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..12f8416774f4849cb4636df198820e47e08257e4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Igammac.pbtxt
@@ -0,0 +1,18 @@
+op {
+  graph_op_name: "Igammac"
+  summary: "Compute the upper regularized incomplete Gamma function `Q(a, x)`."
+  description: <<END
+The upper regularized incomplete Gamma function is defined as:
+
+\\(Q(a, x) = Gamma(a, x) / Gamma(a) = 1 - P(a, x)\\)
+
+where
+
+\\(Gamma(a, x) = int_{x}^{\infty} t^{a-1} exp(-t) dt\\)
+
+is the upper incomplete Gama function.
+
+Note, above `P(a, x)` (`Igamma`) is the lower regularized complete
+Gamma function.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_IgnoreErrorsDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_IgnoreErrorsDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e492d90287f0f1da04ca5a1eba72ed2a6c18e47a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_IgnoreErrorsDataset.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "IgnoreErrorsDataset"
+  summary: "Creates a dataset that contains the elements of `input_dataset` ignoring errors."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Imag.pbtxt b/tensorflow/core/api_def/base_api/api_def_Imag.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8c3bb674311293a92a38f88f0340a667bec3633b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Imag.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "Imag"
+  summary: "Returns the imaginary part of a complex number."
+  description: <<END
+Given a tensor `input` of complex numbers, this operation returns a tensor of
+type `float` that is the imaginary part of each element in `input`. All
+elements in `input` must be complex numbers of the form \\(a + bj\\), where *a*
+is the real part and *b* is the imaginary part returned by this operation.
+
+For example:
+
+```
+# tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
+tf.imag(input) ==> [4.75, 5.75]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ImageSummary.pbtxt b/tensorflow/core/api_def/base_api/api_def_ImageSummary.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9b00f5b19d97500f01916d7e78bdaf9c64b8b66e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ImageSummary.pbtxt
@@ -0,0 +1,70 @@
+op {
+  graph_op_name: "ImageSummary"
+  in_arg {
+    name: "tag"
+    description: <<END
+Scalar. Used to build the `tag` attribute of the summary values.
+END
+  }
+  in_arg {
+    name: "tensor"
+    description: <<END
+4-D of shape `[batch_size, height, width, channels]` where
+`channels` is 1, 3, or 4.
+END
+  }
+  out_arg {
+    name: "summary"
+    description: <<END
+Scalar. Serialized `Summary` protocol buffer.
+END
+  }
+  attr {
+    name: "max_images"
+    description: <<END
+Max number of batch elements to generate images for.
+END
+  }
+  attr {
+    name: "bad_color"
+    description: <<END
+Color to use for pixels with non-finite values.
+END
+  }
+  summary: "Outputs a `Summary` protocol buffer with images."
+  description: <<END
+The summary has up to `max_images` summary values containing images. The
+images are built from `tensor` which must be 4-D with shape `[batch_size,
+height, width, channels]` and where `channels` can be:
+
+*  1: `tensor` is interpreted as Grayscale.
+*  3: `tensor` is interpreted as RGB.
+*  4: `tensor` is interpreted as RGBA.
+
+The images have the same number of channels as the input tensor. For float
+input, the values are normalized one image at a time to fit in the range
+`[0, 255]`.  `uint8` values are unchanged.  The op uses two different
+normalization algorithms:
+
+*  If the input values are all positive, they are rescaled so the largest one
+   is 255.
+
+*  If any input value is negative, the values are shifted so input value 0.0
+   is at 127.  They are then rescaled so that either the smallest value is 0,
+   or the largest one is 255.
+
+The `tag` argument is a scalar `Tensor` of type `string`.  It is used to
+build the `tag` of the summary values:
+
+*  If `max_images` is 1, the summary value tag is '*tag*/image'.
+*  If `max_images` is greater than 1, the summary value tags are
+   generated sequentially as '*tag*/image/0', '*tag*/image/1', etc.
+
+The `bad_color` argument is the color to use in the generated images for
+non-finite input values.  It is a `unit8` 1-D tensor of length `channels`.
+Each element must be in the range `[0, 255]` (It represents the value of a
+pixel in the output image).  Non-finite values in the input tensor are
+replaced by this tensor in the output image.  The default value is the color
+red.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ImmutableConst.pbtxt b/tensorflow/core/api_def/base_api/api_def_ImmutableConst.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..658629df3853d683eac324e9c092e3da5009abd5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ImmutableConst.pbtxt
@@ -0,0 +1,26 @@
+op {
+  graph_op_name: "ImmutableConst"
+  attr {
+    name: "dtype"
+    description: <<END
+Type of the returned tensor.
+END
+  }
+  attr {
+    name: "shape"
+    description: <<END
+Shape of the returned tensor.
+END
+  }
+  attr {
+    name: "memory_region_name"
+    description: <<END
+Name of readonly memory region used by the tensor, see
+NewReadOnlyMemoryRegionFromFile in tensorflow::Env.
+END
+  }
+  summary: "Returns immutable tensor from memory region."
+  description: <<END
+The current implementation memmaps the tensor from a file.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_InTopK.pbtxt b/tensorflow/core/api_def/base_api/api_def_InTopK.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e11d6e59c73d53a75859d1986dd725d180589511
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_InTopK.pbtxt
@@ -0,0 +1,44 @@
+op {
+  graph_op_name: "InTopK"
+  in_arg {
+    name: "predictions"
+    description: <<END
+A `batch_size` x `classes` tensor.
+END
+  }
+  in_arg {
+    name: "targets"
+    description: <<END
+A `batch_size` vector of class ids.
+END
+  }
+  out_arg {
+    name: "precision"
+    description: <<END
+Computed Precision at `k` as a `bool Tensor`.
+END
+  }
+  attr {
+    name: "k"
+    description: <<END
+Number of top elements to look at for computing precision.
+END
+  }
+  summary: "Says whether the targets are in the top `K` predictions."
+  description: <<END
+This outputs a `batch_size` bool array, an entry `out[i]` is `true` if the
+prediction for the target class is among the top `k` predictions among
+all predictions for example `i`. Note that the behavior of `InTopK` differs
+from the `TopK` op in its handling of ties; if multiple classes have the
+same prediction value and straddle the top-`k` boundary, all of those
+classes are considered to be in the top `k`.
+
+More formally, let
+
+  \\(predictions_i\\) be the predictions for all classes for example `i`,
+  \\(targets_i\\) be the target class for example `i`,
+  \\(out_i\\) be the output for example `i`,
+
+$$out_i = predictions_{i, targets_i} \in TopKIncludingTies(predictions_i)$$
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_InTopKV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_InTopKV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6f418ce0ecc2316ca0026bca49a7532855fdcddb
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_InTopKV2.pbtxt
@@ -0,0 +1,44 @@
+op {
+  graph_op_name: "InTopKV2"
+  in_arg {
+    name: "predictions"
+    description: <<END
+A `batch_size` x `classes` tensor.
+END
+  }
+  in_arg {
+    name: "targets"
+    description: <<END
+A `batch_size` vector of class ids.
+END
+  }
+  in_arg {
+    name: "k"
+    description: <<END
+Number of top elements to look at for computing precision.
+END
+  }
+  out_arg {
+    name: "precision"
+    description: <<END
+Computed precision at `k` as a `bool Tensor`.
+END
+  }
+  summary: "Says whether the targets are in the top `K` predictions."
+  description: <<END
+This outputs a `batch_size` bool array, an entry `out[i]` is `true` if the
+prediction for the target class is among the top `k` predictions among
+all predictions for example `i`. Note that the behavior of `InTopK` differs
+from the `TopK` op in its handling of ties; if multiple classes have the
+same prediction value and straddle the top-`k` boundary, all of those
+classes are considered to be in the top `k`.
+
+More formally, let
+
+  \\(predictions_i\\) be the predictions for all classes for example `i`,
+  \\(targets_i\\) be the target class for example `i`,
+  \\(out_i\\) be the output for example `i`,
+
+$$out_i = predictions_{i, targets_i} \in TopKIncludingTies(predictions_i)$$
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_InitializeTable.pbtxt b/tensorflow/core/api_def/base_api/api_def_InitializeTable.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0f9a01a616a085b947543f4d0ae17ba6eafb9325
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_InitializeTable.pbtxt
@@ -0,0 +1,23 @@
+op {
+  graph_op_name: "InitializeTable"
+  visibility: SKIP
+  in_arg {
+    name: "table_handle"
+    description: <<END
+Handle to a table which will be initialized.
+END
+  }
+  in_arg {
+    name: "keys"
+    description: <<END
+Keys of type Tkey.
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+Values of type Tval.
+END
+  }
+  summary: "Table initializer that takes two tensors for keys and values respectively."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_InitializeTableFromTextFile.pbtxt b/tensorflow/core/api_def/base_api/api_def_InitializeTableFromTextFile.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c1b2888cd48796395c041ed4e18029f7ac25cca8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_InitializeTableFromTextFile.pbtxt
@@ -0,0 +1,54 @@
+op {
+  graph_op_name: "InitializeTableFromTextFile"
+  visibility: SKIP
+  in_arg {
+    name: "table_handle"
+    description: <<END
+Handle to a table which will be initialized.
+END
+  }
+  in_arg {
+    name: "filename"
+    description: <<END
+Filename of a vocabulary text file.
+END
+  }
+  attr {
+    name: "key_index"
+    description: <<END
+Column index in a line to get the table `key` values from.
+END
+  }
+  attr {
+    name: "value_index"
+    description: <<END
+Column index that represents information of a line to get the table
+`value` values from.
+END
+  }
+  attr {
+    name: "vocab_size"
+    description: <<END
+Number of elements of the file, use -1 if unknown.
+END
+  }
+  attr {
+    name: "delimiter"
+    description: <<END
+Delimiter to separate fields in a line.
+END
+  }
+  summary: "Initializes a table from a text file."
+  description: <<END
+It inserts one key-value pair into the table for each line of the file.
+The key and value is extracted from the whole line content, elements from the
+split line based on `delimiter` or the line number (starting from zero).
+Where to extract the key and value from a line is specified by `key_index` and
+`value_index`.
+
+- A value of -1 means use the line number(starting from zero), expects `int64`.
+- A value of -2 means use the whole line content, expects `string`.
+- A value >= 0 means use the index (starting at zero) of the split line based
+  on `delimiter`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_InitializeTableFromTextFileV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_InitializeTableFromTextFileV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d2735af4f25a0d0179ab4ca4c2487a4ec5b403f0
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_InitializeTableFromTextFileV2.pbtxt
@@ -0,0 +1,56 @@
+op {
+  graph_op_name: "InitializeTableFromTextFileV2"
+  endpoint {
+    name: "InitializeTableFromTextFile"
+  }
+  in_arg {
+    name: "table_handle"
+    description: <<END
+Handle to a table which will be initialized.
+END
+  }
+  in_arg {
+    name: "filename"
+    description: <<END
+Filename of a vocabulary text file.
+END
+  }
+  attr {
+    name: "key_index"
+    description: <<END
+Column index in a line to get the table `key` values from.
+END
+  }
+  attr {
+    name: "value_index"
+    description: <<END
+Column index that represents information of a line to get the table
+`value` values from.
+END
+  }
+  attr {
+    name: "vocab_size"
+    description: <<END
+Number of elements of the file, use -1 if unknown.
+END
+  }
+  attr {
+    name: "delimiter"
+    description: <<END
+Delimiter to separate fields in a line.
+END
+  }
+  summary: "Initializes a table from a text file."
+  description: <<END
+It inserts one key-value pair into the table for each line of the file.
+The key and value is extracted from the whole line content, elements from the
+split line based on `delimiter` or the line number (starting from zero).
+Where to extract the key and value from a line is specified by `key_index` and
+`value_index`.
+
+- A value of -1 means use the line number(starting from zero), expects `int64`.
+- A value of -2 means use the whole line content, expects `string`.
+- A value >= 0 means use the index (starting at zero) of the split line based
+  on `delimiter`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_InitializeTableV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_InitializeTableV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a32a816da8b14c7c86bdafb7fb594f77af519596
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_InitializeTableV2.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "InitializeTableV2"
+  endpoint {
+    name: "InitializeTable"
+  }
+  in_arg {
+    name: "table_handle"
+    description: <<END
+Handle to a table which will be initialized.
+END
+  }
+  in_arg {
+    name: "keys"
+    description: <<END
+Keys of type Tkey.
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+Values of type Tval.
+END
+  }
+  summary: "Table initializer that takes two tensors for keys and values respectively."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_InterleaveDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_InterleaveDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bec2828e2462227b962bc045d796484a10365452
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_InterleaveDataset.pbtxt
@@ -0,0 +1,19 @@
+op {
+  graph_op_name: "InterleaveDataset"
+  attr {
+    name: "f"
+    description: <<END
+A function mapping elements of `input_dataset`, concatenated with
+`other_arguments`, to a Dataset variant that contains elements matching
+`output_types` and `output_shapes`.
+END
+  }
+  summary: "Creates a dataset that applies `f` to the outputs of `input_dataset`."
+  description: <<END
+Unlike MapDataset, the `f` in InterleaveDataset is expected to return
+a Dataset variant, and InterleaveDataset will flatten successive
+results into a single Dataset. Unlike FlatMapDataset,
+InterleaveDataset will interleave sequences of up to `block_length`
+consecutive elements from `cycle_length` input elements.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Inv.pbtxt b/tensorflow/core/api_def/base_api/api_def_Inv.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fc63276e343cc92ac345d673633141d9f8ce7c31
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Inv.pbtxt
@@ -0,0 +1,7 @@
+op {
+  graph_op_name: "Inv"
+  summary: "Computes the reciprocal of x element-wise."
+  description: <<END
+I.e., \\(y = 1 / x\\).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_InvGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_InvGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..de2f510eb9a6a1e2a5f4d43716b2fe4c9c823320
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_InvGrad.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "InvGrad"
+  visibility: HIDDEN
+  summary: "Computes the gradient for the inverse of `x` wrt its input."
+  description: <<END
+Specifically, `grad = -dy * y*y`, where `y = 1/x`, and `dy`
+is the corresponding input gradient.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Invert.pbtxt b/tensorflow/core/api_def/base_api/api_def_Invert.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4847a500a883ad817407c900babee18e79c37554
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Invert.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "Invert"
+  summary: "Flips all bits elementwise."
+  description: <<END
+The result will have exactly those bits set, that are not set in `x`. The
+computation is performed on the underlying representation of x.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_InvertPermutation.pbtxt b/tensorflow/core/api_def/base_api/api_def_InvertPermutation.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..66062d818ebeeeb9fb9723707c52249364f7ccba
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_InvertPermutation.pbtxt
@@ -0,0 +1,33 @@
+op {
+  graph_op_name: "InvertPermutation"
+  in_arg {
+    name: "x"
+    description: <<END
+1-D.
+END
+  }
+  out_arg {
+    name: "y"
+    description: <<END
+1-D.
+END
+  }
+  summary: "Computes the inverse permutation of a tensor."
+  description: <<END
+This operation computes the inverse of an index permutation. It takes a 1-D
+integer tensor `x`, which represents the indices of a zero-based array, and
+swaps each value with its index position. In other words, for an output tensor
+`y` and an input tensor `x`, this operation computes the following:
+
+`y[x[i]] = i for i in [0, 1, ..., len(x) - 1]`
+
+The values must include 0. There can be no duplicate values or negative values.
+
+For example:
+
+```
+# tensor `x` is [3, 4, 0, 2, 1]
+invert_permutation(x) ==> [2, 4, 3, 0, 1]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_IsFinite.pbtxt b/tensorflow/core/api_def/base_api/api_def_IsFinite.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bccc0e32c15a677d22a8868105ad2d3cb90ebf91
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_IsFinite.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "IsFinite"
+  summary: "Returns which elements of x are finite."
+  description: <<END
+@compatibility(numpy)
+Equivalent to np.isfinite
+@end_compatibility
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_IsInf.pbtxt b/tensorflow/core/api_def/base_api/api_def_IsInf.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5c390f32d3490f65156dc5b2b229dfc2418cfd4f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_IsInf.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "IsInf"
+  summary: "Returns which elements of x are Inf."
+  description: <<END
+@compatibility(numpy)
+Equivalent to np.isinf
+@end_compatibility
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_IsNan.pbtxt b/tensorflow/core/api_def/base_api/api_def_IsNan.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1487fad927216fbb08a5d3779e7e8e7a5aa9dff3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_IsNan.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "IsNan"
+  summary: "Returns which elements of x are NaN."
+  description: <<END
+@compatibility(numpy)
+Equivalent to np.isnan
+@end_compatibility
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_IsVariableInitialized.pbtxt b/tensorflow/core/api_def/base_api/api_def_IsVariableInitialized.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d631da711d2ed698203717ddebb48c7b219f5f4c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_IsVariableInitialized.pbtxt
@@ -0,0 +1,19 @@
+op {
+  graph_op_name: "IsVariableInitialized"
+  in_arg {
+    name: "ref"
+    description: <<END
+Should be from a `Variable` node. May be uninitialized.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of elements in the variable tensor.
+END
+  }
+  summary: "Checks whether a tensor has been initialized."
+  description: <<END
+Outputs boolean scalar indicating whether the tensor has been initialized.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Iterator.pbtxt b/tensorflow/core/api_def/base_api/api_def_Iterator.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..660267c221510f489e85733ea32fbac4903d8fdb
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Iterator.pbtxt
@@ -0,0 +1,11 @@
+op {
+  graph_op_name: "Iterator"
+  out_arg {
+    name: "handle"
+    description: <<END
+A handle to the iterator that can be passed to a "MakeIterator"
+or "IteratorGetNext" op.
+END
+  }
+  summary: "A container for an iterator resource."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_IteratorFromStringHandle.pbtxt b/tensorflow/core/api_def/base_api/api_def_IteratorFromStringHandle.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cd7e382edb376599c8b3bf9af21c441771e7ef9e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_IteratorFromStringHandle.pbtxt
@@ -0,0 +1,30 @@
+op {
+  graph_op_name: "IteratorFromStringHandle"
+  in_arg {
+    name: "string_handle"
+    description: <<END
+A string representation of the given handle.
+END
+  }
+  out_arg {
+    name: "resource_handle"
+    description: <<END
+A handle to an iterator resource.
+END
+  }
+  attr {
+    name: "output_types"
+    description: <<END
+If specified, defines the type of each tuple component in an
+element produced by the resulting iterator.
+END
+  }
+  attr {
+    name: "output_shapes"
+    description: <<END
+If specified, defines the shape of each tuple component in an
+element produced by the resulting iterator.
+END
+  }
+  summary: "Converts the given string representing a handle to an iterator to a resource."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_IteratorGetNext.pbtxt b/tensorflow/core/api_def/base_api/api_def_IteratorGetNext.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ea5669693e09c576d6cf9039846903a317c3b128
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_IteratorGetNext.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "IteratorGetNext"
+  summary: "Gets the next output from the given iterator."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_IteratorToStringHandle.pbtxt b/tensorflow/core/api_def/base_api/api_def_IteratorToStringHandle.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cf446b41273de53d674f70dcccc8db844f33cd04
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_IteratorToStringHandle.pbtxt
@@ -0,0 +1,16 @@
+op {
+  graph_op_name: "IteratorToStringHandle"
+  in_arg {
+    name: "resource_handle"
+    description: <<END
+A handle to an iterator resource.
+END
+  }
+  out_arg {
+    name: "string_handle"
+    description: <<END
+A string representation of the given handle.
+END
+  }
+  summary: "Converts the given `resource_handle` representing an iterator to a string."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_L.pbtxt b/tensorflow/core/api_def/base_api/api_def_L.pbtxt
deleted file mode 100644
index 09e55eacc7e2763511389434e2a4a308b76ea58e..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_L.pbtxt
+++ /dev/null
@@ -1,392 +0,0 @@
-op {
-  graph_op_name: "L2Loss"
-  endpoint {
-    name: "L2Loss"
-  }
-  summary: "L2 Loss."
-  description: <<END
-Computes half the L2 norm of a tensor without the `sqrt`:
-
-    output = sum(t ** 2) / 2
-END
-}
-op {
-  graph_op_name: "LMDBReader"
-  endpoint {
-    name: "LMDBReader"
-  }
-  summary: "A Reader that outputs the records from a LMDB file."
-}
-op {
-  graph_op_name: "LRN"
-  endpoint {
-    name: "LRN"
-  }
-  summary: "Local Response Normalization."
-  description: <<END
-The 4-D `input` tensor is treated as a 3-D array of 1-D vectors (along the last
-dimension), and each vector is normalized independently.  Within a given vector,
-each component is divided by the weighted, squared sum of inputs within
-`depth_radius`.  In detail,
-
-    sqr_sum[a, b, c, d] =
-        sum(input[a, b, c, d - depth_radius : d + depth_radius + 1] ** 2)
-    output = input / (bias + alpha * sqr_sum) ** beta
-
-For details, see [Krizhevsky et al., ImageNet classification with deep
-convolutional neural networks (NIPS 2012)](http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks).
-END
-}
-op {
-  graph_op_name: "LRNGrad"
-  endpoint {
-    name: "LRNGrad"
-  }
-  summary: "Gradients for Local Response Normalization."
-}
-op {
-  graph_op_name: "LearnedUnigramCandidateSampler"
-  endpoint {
-    name: "LearnedUnigramCandidateSampler"
-  }
-  summary: "Generates labels for candidate sampling with a learned unigram distribution."
-  description: <<END
-See explanations of candidate sampling and the data formats at
-go/candidate-sampling.
-
-For each batch, this op picks a single set of sampled candidate labels.
-
-The advantages of sampling candidates per-batch are simplicity and the
-possibility of efficient dense matrix multiplication. The disadvantage is that
-the sampled candidates must be chosen independently of the context and of the
-true labels.
-END
-}
-op {
-  graph_op_name: "Less"
-  endpoint {
-    name: "Less"
-  }
-  summary: "Returns the truth value of (x < y) element-wise."
-  description: <<END
-*NOTE*: `Less` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "LessEqual"
-  endpoint {
-    name: "LessEqual"
-  }
-  summary: "Returns the truth value of (x <= y) element-wise."
-  description: <<END
-*NOTE*: `LessEqual` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "Lgamma"
-  endpoint {
-    name: "Lgamma"
-  }
-  summary: "Computes the log of the absolute value of `Gamma(x)` element-wise."
-}
-op {
-  graph_op_name: "LinSpace"
-  endpoint {
-    name: "LinSpace"
-  }
-  summary: "Generates values in an interval."
-  description: <<END
-A sequence of `num` evenly-spaced values are generated beginning at `start`.
-If `num > 1`, the values in the sequence increase by `stop - start / num - 1`,
-so that the last one is exactly `stop`.
-
-For example:
-
-```
-tf.linspace(10.0, 12.0, 3, name="linspace") => [ 10.0  11.0  12.0]
-```
-END
-}
-op {
-  graph_op_name: "ListDiff"
-  endpoint {
-    name: "ListDiff"
-  }
-  summary: "Computes the difference between two lists of numbers or strings."
-  description: <<END
-Given a list `x` and a list `y`, this operation returns a list `out` that
-represents all values that are in `x` but not in `y`. The returned list `out`
-is sorted in the same order that the numbers appear in `x` (duplicates are
-preserved). This operation also returns a list `idx` that represents the
-position of each `out` element in `x`. In other words:
-
-`out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]`
-
-For example, given this input:
-
-```
-x = [1, 2, 3, 4, 5, 6]
-y = [1, 3, 5]
-```
-
-This operation would return:
-
-```
-out ==> [2, 4, 6]
-idx ==> [1, 3, 5]
-```
-END
-}
-op {
-  graph_op_name: "LoadAndRemapMatrix"
-  endpoint {
-    name: "LoadAndRemapMatrix"
-  }
-  summary: "Loads a 2-D (matrix) `Tensor` with name `old_tensor_name` from the checkpoint"
-  description: <<END
-at `ckpt_path` and potentially reorders its rows and columns using the
-specified remappings.
-
-Most users should use one of the wrapper initializers (such as
-`tf.contrib.framework.load_and_remap_matrix_initializer`) instead of this
-function directly.
-
-The remappings are 1-D tensors with the following properties:
-
-* `row_remapping` must have exactly `num_rows` entries. Row `i` of the output
-  matrix will be initialized from the row corresponding to index
-  `row_remapping[i]` in the old `Tensor` from the checkpoint.
-* `col_remapping` must have either 0 entries (indicating that no column
-  reordering is needed) or `num_cols` entries. If specified, column `j` of the
-  output matrix will be initialized from the column corresponding to index
-  `col_remapping[j]` in the old `Tensor` from the checkpoint.
-* A value of -1 in either of the remappings signifies a "missing" entry. In that
-  case, values from the `initializing_values` tensor will be used to fill that
-  missing row or column. If `row_remapping` has `r` missing entries and
-  `col_remapping` has `c` missing entries, then the following condition must be
-  true:
-
-`(r * num_cols) + (c * num_rows) - (r * c) == len(initializing_values)`
-
-The remapping tensors can be generated using the GenerateVocabRemapping op.
-
-As an example, with row_remapping = [1, 0, -1], col_remapping = [0, 2, -1],
-initializing_values = [0.5, -0.5, 0.25, -0.25, 42], and w(i, j) representing
-the value from row i, column j of the old tensor in the checkpoint, the output
-matrix will look like the following:
-
-[[w(1, 0),  w(1, 2),  0.5],
- [w(0, 0),  w(0, 2), -0.5],
- [0.25,    -0.25,      42]]
-END
-}
-op {
-  graph_op_name: "Log"
-  endpoint {
-    name: "Log"
-  }
-  summary: "Computes natural logarithm of x element-wise."
-  description: <<END
-I.e., \\(y = \log_e x\\).
-END
-}
-op {
-  graph_op_name: "Log1p"
-  endpoint {
-    name: "Log1p"
-  }
-  summary: "Computes natural logarithm of (1 + x) element-wise."
-  description: <<END
-I.e., \\(y = \log_e (1 + x)\\).
-END
-}
-op {
-  graph_op_name: "LogMatrixDeterminant"
-  endpoint {
-    name: "LogMatrixDeterminant"
-  }
-  summary: "Computes the sign and the log of the absolute value of the determinant of"
-  description: <<END
-one or more square matrices.
-
-The input is a tensor of shape `[N, M, M]` whose inner-most 2 dimensions
-form square matrices. The outputs are two tensors containing the signs and
-absolute values of the log determinants for all N input submatrices
-`[..., :, :]` such that the determinant = sign*exp(log_abs_determinant).
-The log_abs_determinant is computed as det(P)*sum(log(diag(LU))) where LU
-is the LU decomposition of the input and P is the corresponding
-permutation matrix.
-END
-}
-op {
-  graph_op_name: "LogSoftmax"
-  endpoint {
-    name: "LogSoftmax"
-  }
-  summary: "Computes log softmax activations."
-  description: <<END
-For each batch `i` and class `j` we have
-
-    logsoftmax[i, j] = logits[i, j] - log(sum(exp(logits[i])))
-END
-}
-op {
-  graph_op_name: "LogUniformCandidateSampler"
-  endpoint {
-    name: "LogUniformCandidateSampler"
-  }
-  summary: "Generates labels for candidate sampling with a log-uniform distribution."
-  description: <<END
-See explanations of candidate sampling and the data formats at
-go/candidate-sampling.
-
-For each batch, this op picks a single set of sampled candidate labels.
-
-The advantages of sampling candidates per-batch are simplicity and the
-possibility of efficient dense matrix multiplication. The disadvantage is that
-the sampled candidates must be chosen independently of the context and of the
-true labels.
-END
-}
-op {
-  graph_op_name: "LogicalAnd"
-  endpoint {
-    name: "LogicalAnd"
-  }
-  summary: "Returns the truth value of x AND y element-wise."
-  description: <<END
-*NOTE*: `LogicalAnd` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "LogicalNot"
-  endpoint {
-    name: "LogicalNot"
-  }
-  summary: "Returns the truth value of NOT x element-wise."
-}
-op {
-  graph_op_name: "LogicalOr"
-  endpoint {
-    name: "LogicalOr"
-  }
-  summary: "Returns the truth value of x OR y element-wise."
-  description: <<END
-*NOTE*: `LogicalOr` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "LookupTableExport"
-  endpoint {
-    name: "LookupTableExport"
-  }
-  summary: "Outputs all keys and values in the table."
-}
-op {
-  graph_op_name: "LookupTableExportV2"
-  endpoint {
-    name: "LookupTableExportV2"
-  }
-  summary: "Outputs all keys and values in the table."
-}
-op {
-  graph_op_name: "LookupTableFind"
-  endpoint {
-    name: "LookupTableFind"
-  }
-  summary: "Looks up keys in a table, outputs the corresponding values."
-  description: <<END
-The tensor `keys` must of the same type as the keys of the table.
-The output `values` is of the type of the table values.
-
-The scalar `default_value` is the value output for keys not present in the
-table. It must also be of the same type as the table values.
-END
-}
-op {
-  graph_op_name: "LookupTableFindV2"
-  endpoint {
-    name: "LookupTableFindV2"
-  }
-  summary: "Looks up keys in a table, outputs the corresponding values."
-  description: <<END
-The tensor `keys` must of the same type as the keys of the table.
-The output `values` is of the type of the table values.
-
-The scalar `default_value` is the value output for keys not present in the
-table. It must also be of the same type as the table values.
-END
-}
-op {
-  graph_op_name: "LookupTableImport"
-  endpoint {
-    name: "LookupTableImport"
-  }
-  summary: "Replaces the contents of the table with the specified keys and values."
-  description: <<END
-The tensor `keys` must be of the same type as the keys of the table.
-The tensor `values` must be of the type of the table values.
-END
-}
-op {
-  graph_op_name: "LookupTableImportV2"
-  endpoint {
-    name: "LookupTableImportV2"
-  }
-  summary: "Replaces the contents of the table with the specified keys and values."
-  description: <<END
-The tensor `keys` must be of the same type as the keys of the table.
-The tensor `values` must be of the type of the table values.
-END
-}
-op {
-  graph_op_name: "LookupTableInsert"
-  endpoint {
-    name: "LookupTableInsert"
-  }
-  summary: "Updates the table to associates keys with values."
-  description: <<END
-The tensor `keys` must be of the same type as the keys of the table.
-The tensor `values` must be of the type of the table values.
-END
-}
-op {
-  graph_op_name: "LookupTableInsertV2"
-  endpoint {
-    name: "LookupTableInsertV2"
-  }
-  summary: "Updates the table to associates keys with values."
-  description: <<END
-The tensor `keys` must be of the same type as the keys of the table.
-The tensor `values` must be of the type of the table values.
-END
-}
-op {
-  graph_op_name: "LookupTableSize"
-  endpoint {
-    name: "LookupTableSize"
-  }
-  summary: "Computes the number of elements in the given table."
-}
-op {
-  graph_op_name: "LookupTableSizeV2"
-  endpoint {
-    name: "LookupTableSizeV2"
-  }
-  summary: "Computes the number of elements in the given table."
-}
-op {
-  graph_op_name: "LoopCond"
-  endpoint {
-    name: "LoopCond"
-  }
-  summary: "Forwards the input to the output."
-  description: <<END
-This operator represents the loop termination condition used by the
-"pivot" switches of a loop.
-END
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_L2Loss.pbtxt b/tensorflow/core/api_def/base_api/api_def_L2Loss.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..eaf4b4ec355e08207f56435e406a5a214e09e0c4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_L2Loss.pbtxt
@@ -0,0 +1,21 @@
+op {
+  graph_op_name: "L2Loss"
+  in_arg {
+    name: "t"
+    description: <<END
+Typically 2-D, but may have any dimensions.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+0-D.
+END
+  }
+  summary: "L2 Loss."
+  description: <<END
+Computes half the L2 norm of a tensor without the `sqrt`:
+
+    output = sum(t ** 2) / 2
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LMDBReader.pbtxt b/tensorflow/core/api_def/base_api/api_def_LMDBReader.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..28d19e8658e1e2853a048da4ffc4032b3657b21e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LMDBReader.pbtxt
@@ -0,0 +1,24 @@
+op {
+  graph_op_name: "LMDBReader"
+  out_arg {
+    name: "reader_handle"
+    description: <<END
+The handle to reference the Reader.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this reader is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this reader is named in the given bucket
+with this shared_name. Otherwise, the node name is used instead.
+END
+  }
+  summary: "A Reader that outputs the records from a LMDB file."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LRN.pbtxt b/tensorflow/core/api_def/base_api/api_def_LRN.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..97108821864f39a5a510bbe06a6cd7f474f0c3d5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LRN.pbtxt
@@ -0,0 +1,47 @@
+op {
+  graph_op_name: "LRN"
+  in_arg {
+    name: "input"
+    description: <<END
+4-D.
+END
+  }
+  attr {
+    name: "depth_radius"
+    description: <<END
+0-D.  Half-width of the 1-D normalization window.
+END
+  }
+  attr {
+    name: "bias"
+    description: <<END
+An offset (usually positive to avoid dividing by 0).
+END
+  }
+  attr {
+    name: "alpha"
+    description: <<END
+A scale factor, usually positive.
+END
+  }
+  attr {
+    name: "beta"
+    description: <<END
+An exponent.
+END
+  }
+  summary: "Local Response Normalization."
+  description: <<END
+The 4-D `input` tensor is treated as a 3-D array of 1-D vectors (along the last
+dimension), and each vector is normalized independently.  Within a given vector,
+each component is divided by the weighted, squared sum of inputs within
+`depth_radius`.  In detail,
+
+    sqr_sum[a, b, c, d] =
+        sum(input[a, b, c, d - depth_radius : d + depth_radius + 1] ** 2)
+    output = input / (bias + alpha * sqr_sum) ** beta
+
+For details, see [Krizhevsky et al., ImageNet classification with deep
+convolutional neural networks (NIPS 2012)](http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LRNGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_LRNGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6b2b289ba68843a6cd725109b138822f8e72bb69
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LRNGrad.pbtxt
@@ -0,0 +1,53 @@
+op {
+  graph_op_name: "LRNGrad"
+  visibility: HIDDEN
+  in_arg {
+    name: "input_grads"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.
+END
+  }
+  in_arg {
+    name: "input_image"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.
+END
+  }
+  in_arg {
+    name: "output_image"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The gradients for LRN.
+END
+  }
+  attr {
+    name: "depth_radius"
+    description: <<END
+A depth radius.
+END
+  }
+  attr {
+    name: "bias"
+    description: <<END
+An offset (usually > 0 to avoid dividing by 0).
+END
+  }
+  attr {
+    name: "alpha"
+    description: <<END
+A scale factor, usually positive.
+END
+  }
+  attr {
+    name: "beta"
+    description: <<END
+An exponent.
+END
+  }
+  summary: "Gradients for Local Response Normalization."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LearnedUnigramCandidateSampler.pbtxt b/tensorflow/core/api_def/base_api/api_def_LearnedUnigramCandidateSampler.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7097884fde31a4b0a7b3d4d51309556c5285f2d9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LearnedUnigramCandidateSampler.pbtxt
@@ -0,0 +1,86 @@
+op {
+  graph_op_name: "LearnedUnigramCandidateSampler"
+  in_arg {
+    name: "true_classes"
+    description: <<END
+A batch_size * num_true matrix, in which each row contains the
+IDs of the num_true target_classes in the corresponding original label.
+END
+  }
+  out_arg {
+    name: "sampled_candidates"
+    description: <<END
+A vector of length num_sampled, in which each element is
+the ID of a sampled candidate.
+END
+  }
+  out_arg {
+    name: "true_expected_count"
+    description: <<END
+A batch_size * num_true matrix, representing
+the number of times each candidate is expected to occur in a batch
+of sampled candidates. If unique=true, then this is a probability.
+END
+  }
+  out_arg {
+    name: "sampled_expected_count"
+    description: <<END
+A vector of length num_sampled, for each sampled
+candidate representing the number of times the candidate is expected
+to occur in a batch of sampled candidates.  If unique=true, then this is a
+probability.
+END
+  }
+  attr {
+    name: "num_true"
+    description: <<END
+Number of true labels per context.
+END
+  }
+  attr {
+    name: "num_sampled"
+    description: <<END
+Number of candidates to randomly sample.
+END
+  }
+  attr {
+    name: "unique"
+    description: <<END
+If unique is true, we sample with rejection, so that all sampled
+candidates in a batch are unique. This requires some approximation to
+estimate the post-rejection sampling probabilities.
+END
+  }
+  attr {
+    name: "range_max"
+    description: <<END
+The sampler will sample integers from the interval [0, range_max).
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either seed or seed2 are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+An second seed to avoid seed collision.
+END
+  }
+  summary: "Generates labels for candidate sampling with a learned unigram distribution."
+  description: <<END
+See explanations of candidate sampling and the data formats at
+go/candidate-sampling.
+
+For each batch, this op picks a single set of sampled candidate labels.
+
+The advantages of sampling candidates per-batch are simplicity and the
+possibility of efficient dense matrix multiplication. The disadvantage is that
+the sampled candidates must be chosen independently of the context and of the
+true labels.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LeftShift.pbtxt b/tensorflow/core/api_def/base_api/api_def_LeftShift.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..622a90d0c7f5838bd8472202a2dae2231673ea33
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LeftShift.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "LeftShift"
+  summary: "Elementwise computes the bitwise left-shift of `x` and `y`."
+  description: <<END
+If `y` is negative, or greater than or equal to the width of `x` in bits the
+result is implementation defined.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Less.pbtxt b/tensorflow/core/api_def/base_api/api_def_Less.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..104d583f42a50998ea557bba6e18d6c7c6b8255d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Less.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "Less"
+  summary: "Returns the truth value of (x < y) element-wise."
+  description: <<END
+*NOTE*: `Less` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LessEqual.pbtxt b/tensorflow/core/api_def/base_api/api_def_LessEqual.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..637fe2f47ef41f5fb04895f2ac9e00c757f7b074
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LessEqual.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "LessEqual"
+  summary: "Returns the truth value of (x <= y) element-wise."
+  description: <<END
+*NOTE*: `LessEqual` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Lgamma.pbtxt b/tensorflow/core/api_def/base_api/api_def_Lgamma.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fa93f30f387c61ceebde126a0aceb700ad9007bb
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Lgamma.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Lgamma"
+  summary: "Computes the log of the absolute value of `Gamma(x)` element-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LinSpace.pbtxt b/tensorflow/core/api_def/base_api/api_def_LinSpace.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..94a4ef574d9d4e61e6c7336bc2468089a852ad04
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LinSpace.pbtxt
@@ -0,0 +1,39 @@
+op {
+  graph_op_name: "LinSpace"
+  in_arg {
+    name: "start"
+    description: <<END
+First entry in the range.
+END
+  }
+  in_arg {
+    name: "stop"
+    description: <<END
+Last entry in the range.
+END
+  }
+  in_arg {
+    name: "num"
+    description: <<END
+Number of values to generate.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+1-D. The generated values.
+END
+  }
+  summary: "Generates values in an interval."
+  description: <<END
+A sequence of `num` evenly-spaced values are generated beginning at `start`.
+If `num > 1`, the values in the sequence increase by `stop - start / num - 1`,
+so that the last one is exactly `stop`.
+
+For example:
+
+```
+tf.linspace(10.0, 12.0, 3, name="linspace") => [ 10.0  11.0  12.0]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ListDiff.pbtxt b/tensorflow/core/api_def/base_api/api_def_ListDiff.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..60a91dfaa65eb7e102a965978d55d508430dcb16
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ListDiff.pbtxt
@@ -0,0 +1,54 @@
+op {
+  graph_op_name: "ListDiff"
+  endpoint {
+    name: "SetDiff1D"
+  }
+  in_arg {
+    name: "x"
+    description: <<END
+1-D. Values to keep.
+END
+  }
+  in_arg {
+    name: "y"
+    description: <<END
+1-D. Values to remove.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+1-D. Values present in `x` but not in `y`.
+END
+  }
+  out_arg {
+    name: "idx"
+    description: <<END
+1-D. Positions of `x` values preserved in `out`.
+END
+  }
+  summary: "Computes the difference between two lists of numbers or strings."
+  description: <<END
+Given a list `x` and a list `y`, this operation returns a list `out` that
+represents all values that are in `x` but not in `y`. The returned list `out`
+is sorted in the same order that the numbers appear in `x` (duplicates are
+preserved). This operation also returns a list `idx` that represents the
+position of each `out` element in `x`. In other words:
+
+`out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]`
+
+For example, given this input:
+
+```
+x = [1, 2, 3, 4, 5, 6]
+y = [1, 3, 5]
+```
+
+This operation would return:
+
+```
+out ==> [2, 4, 6]
+idx ==> [1, 3, 5]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LoadAndRemapMatrix.pbtxt b/tensorflow/core/api_def/base_api/api_def_LoadAndRemapMatrix.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e1e7007f078b4c88704a69863315bd52a1bfa813
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LoadAndRemapMatrix.pbtxt
@@ -0,0 +1,105 @@
+op {
+  graph_op_name: "LoadAndRemapMatrix"
+  in_arg {
+    name: "ckpt_path"
+    description: <<END
+Path to the TensorFlow checkpoint (version 2, `TensorBundle`) from
+which the old matrix `Tensor` will be loaded.
+END
+  }
+  in_arg {
+    name: "old_tensor_name"
+    description: <<END
+Name of the 2-D `Tensor` to load from checkpoint.
+END
+  }
+  in_arg {
+    name: "row_remapping"
+    description: <<END
+An int `Tensor` of row remappings (generally created by
+`generate_vocab_remapping`).  Even if no row remapping is needed, this must
+still be an index-valued Tensor (e.g. [0, 1, 2, ...]), or a shifted
+index-valued `Tensor` (e.g. [8, 9, 10, ...], for partitioned `Variables`).
+END
+  }
+  in_arg {
+    name: "col_remapping"
+    description: <<END
+An int `Tensor` of column remappings (generally created by
+`generate_vocab_remapping`).  May be a size-0 `Tensor` if only row remapping
+is to be done (e.g. column ordering is the same).
+END
+  }
+  in_arg {
+    name: "initializing_values"
+    description: <<END
+A float `Tensor` containing  values to fill in for cells
+in the output matrix that are not loaded from the checkpoint. Length must be
+exactly the same as the number of missing / new cells.
+END
+  }
+  out_arg {
+    name: "output_matrix"
+    description: <<END
+Output matrix containing existing values loaded from the
+checkpoint, and with any missing values filled in from initializing_values.
+END
+  }
+  attr {
+    name: "num_rows"
+    description: <<END
+Number of rows (length of the 1st dimension) in the output matrix.
+END
+  }
+  attr {
+    name: "num_cols"
+    description: <<END
+Number of columns (length of the 2nd dimension) in the output matrix.
+END
+  }
+  attr {
+    name: "max_rows_in_memory"
+    description: <<END
+The maximum number of rows to load from the checkpoint at
+once. If less than or equal to 0, the entire matrix will be loaded into
+memory. Setting this arg trades increased disk reads for lower memory usage.
+END
+  }
+  summary: "Loads a 2-D (matrix) `Tensor` with name `old_tensor_name` from the checkpoint"
+  description: <<END
+at `ckpt_path` and potentially reorders its rows and columns using the
+specified remappings.
+
+Most users should use one of the wrapper initializers (such as
+`tf.contrib.framework.load_and_remap_matrix_initializer`) instead of this
+function directly.
+
+The remappings are 1-D tensors with the following properties:
+
+* `row_remapping` must have exactly `num_rows` entries. Row `i` of the output
+  matrix will be initialized from the row corresponding to index
+  `row_remapping[i]` in the old `Tensor` from the checkpoint.
+* `col_remapping` must have either 0 entries (indicating that no column
+  reordering is needed) or `num_cols` entries. If specified, column `j` of the
+  output matrix will be initialized from the column corresponding to index
+  `col_remapping[j]` in the old `Tensor` from the checkpoint.
+* A value of -1 in either of the remappings signifies a "missing" entry. In that
+  case, values from the `initializing_values` tensor will be used to fill that
+  missing row or column. If `row_remapping` has `r` missing entries and
+  `col_remapping` has `c` missing entries, then the following condition must be
+  true:
+
+`(r * num_cols) + (c * num_rows) - (r * c) == len(initializing_values)`
+
+The remapping tensors can be generated using the GenerateVocabRemapping op.
+
+As an example, with row_remapping = [1, 0, -1], col_remapping = [0, 2, -1],
+initializing_values = [0.5, -0.5, 0.25, -0.25, 42], and w(i, j) representing
+the value from row i, column j of the old tensor in the checkpoint, the output
+matrix will look like the following:
+
+[[w(1, 0),  w(1, 2),  0.5],
+ [w(0, 0),  w(0, 2), -0.5],
+ [0.25,    -0.25,      42]]
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Log.pbtxt b/tensorflow/core/api_def/base_api/api_def_Log.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..056f1bc2e275fdd95a9aebc02577a6b74c490a84
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Log.pbtxt
@@ -0,0 +1,7 @@
+op {
+  graph_op_name: "Log"
+  summary: "Computes natural logarithm of x element-wise."
+  description: <<END
+I.e., \\(y = \log_e x\\).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Log1p.pbtxt b/tensorflow/core/api_def/base_api/api_def_Log1p.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cc9eb2682e76ecc2f34da213f2a5694502ec48b3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Log1p.pbtxt
@@ -0,0 +1,7 @@
+op {
+  graph_op_name: "Log1p"
+  summary: "Computes natural logarithm of (1 + x) element-wise."
+  description: <<END
+I.e., \\(y = \log_e (1 + x)\\).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LogMatrixDeterminant.pbtxt b/tensorflow/core/api_def/base_api/api_def_LogMatrixDeterminant.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8245f7d300c3e703a99a823c0c2309e6224de28d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LogMatrixDeterminant.pbtxt
@@ -0,0 +1,34 @@
+op {
+  graph_op_name: "LogMatrixDeterminant"
+  in_arg {
+    name: "input"
+    description: <<END
+Shape is `[N, M, M]`.
+END
+  }
+  out_arg {
+    name: "sign"
+    description: <<END
+The signs of the log determinants of the inputs. Shape is `[N]`.
+END
+  }
+  out_arg {
+    name: "log_abs_determinant"
+    description: <<END
+The logs of the absolute values of the determinants
+of the N input matrices.  Shape is `[N]`.
+END
+  }
+  summary: "Computes the sign and the log of the absolute value of the determinant of"
+  description: <<END
+one or more square matrices.
+
+The input is a tensor of shape `[N, M, M]` whose inner-most 2 dimensions
+form square matrices. The outputs are two tensors containing the signs and
+absolute values of the log determinants for all N input submatrices
+`[..., :, :]` such that the determinant = sign*exp(log_abs_determinant).
+The log_abs_determinant is computed as det(P)*sum(log(diag(LU))) where LU
+is the LU decomposition of the input and P is the corresponding
+permutation matrix.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LogSoftmax.pbtxt b/tensorflow/core/api_def/base_api/api_def_LogSoftmax.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ba02abdd0aeba28dfb93f13e90d94532f03209be
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LogSoftmax.pbtxt
@@ -0,0 +1,21 @@
+op {
+  graph_op_name: "LogSoftmax"
+  in_arg {
+    name: "logits"
+    description: <<END
+2-D with shape `[batch_size, num_classes]`.
+END
+  }
+  out_arg {
+    name: "logsoftmax"
+    description: <<END
+Same shape as `logits`.
+END
+  }
+  summary: "Computes log softmax activations."
+  description: <<END
+For each batch `i` and class `j` we have
+
+    logsoftmax[i, j] = logits[i, j] - log(sum(exp(logits[i])))
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LogUniformCandidateSampler.pbtxt b/tensorflow/core/api_def/base_api/api_def_LogUniformCandidateSampler.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9c6807bcb288edf75d460e9522efd1176d3512ba
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LogUniformCandidateSampler.pbtxt
@@ -0,0 +1,86 @@
+op {
+  graph_op_name: "LogUniformCandidateSampler"
+  in_arg {
+    name: "true_classes"
+    description: <<END
+A batch_size * num_true matrix, in which each row contains the
+IDs of the num_true target_classes in the corresponding original label.
+END
+  }
+  out_arg {
+    name: "sampled_candidates"
+    description: <<END
+A vector of length num_sampled, in which each element is
+the ID of a sampled candidate.
+END
+  }
+  out_arg {
+    name: "true_expected_count"
+    description: <<END
+A batch_size * num_true matrix, representing
+the number of times each candidate is expected to occur in a batch
+of sampled candidates. If unique=true, then this is a probability.
+END
+  }
+  out_arg {
+    name: "sampled_expected_count"
+    description: <<END
+A vector of length num_sampled, for each sampled
+candidate representing the number of times the candidate is expected
+to occur in a batch of sampled candidates.  If unique=true, then this is a
+probability.
+END
+  }
+  attr {
+    name: "num_true"
+    description: <<END
+Number of true labels per context.
+END
+  }
+  attr {
+    name: "num_sampled"
+    description: <<END
+Number of candidates to randomly sample.
+END
+  }
+  attr {
+    name: "unique"
+    description: <<END
+If unique is true, we sample with rejection, so that all sampled
+candidates in a batch are unique. This requires some approximation to
+estimate the post-rejection sampling probabilities.
+END
+  }
+  attr {
+    name: "range_max"
+    description: <<END
+The sampler will sample integers from the interval [0, range_max).
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either seed or seed2 are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+An second seed to avoid seed collision.
+END
+  }
+  summary: "Generates labels for candidate sampling with a log-uniform distribution."
+  description: <<END
+See explanations of candidate sampling and the data formats at
+go/candidate-sampling.
+
+For each batch, this op picks a single set of sampled candidate labels.
+
+The advantages of sampling candidates per-batch are simplicity and the
+possibility of efficient dense matrix multiplication. The disadvantage is that
+the sampled candidates must be chosen independently of the context and of the
+true labels.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LogicalAnd.pbtxt b/tensorflow/core/api_def/base_api/api_def_LogicalAnd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4ec78d02b097918fc02f705990f0648f91946d2d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LogicalAnd.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "LogicalAnd"
+  summary: "Returns the truth value of x AND y element-wise."
+  description: <<END
+*NOTE*: `LogicalAnd` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LogicalNot.pbtxt b/tensorflow/core/api_def/base_api/api_def_LogicalNot.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..af29e920c9bc5626849b4aa9dc5bb3798f738556
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LogicalNot.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "LogicalNot"
+  summary: "Returns the truth value of NOT x element-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LogicalOr.pbtxt b/tensorflow/core/api_def/base_api/api_def_LogicalOr.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b4f31cd5213d5b9c577073c1f10e2c0c0a1d03a3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LogicalOr.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "LogicalOr"
+  summary: "Returns the truth value of x OR y element-wise."
+  description: <<END
+*NOTE*: `LogicalOr` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LookupTableExport.pbtxt b/tensorflow/core/api_def/base_api/api_def_LookupTableExport.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..dfc721ddee64afaf3f0e508f28ef82cfdc340efa
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LookupTableExport.pbtxt
@@ -0,0 +1,23 @@
+op {
+  graph_op_name: "LookupTableExport"
+  visibility: SKIP
+  in_arg {
+    name: "table_handle"
+    description: <<END
+Handle to the table.
+END
+  }
+  out_arg {
+    name: "keys"
+    description: <<END
+Vector of all keys present in the table.
+END
+  }
+  out_arg {
+    name: "values"
+    description: <<END
+Tensor of all values in the table. Indexed in parallel with `keys`.
+END
+  }
+  summary: "Outputs all keys and values in the table."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LookupTableExportV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_LookupTableExportV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2bc944c9180442a6385534c9e0e89ae148dff5de
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LookupTableExportV2.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "LookupTableExportV2"
+  endpoint {
+    name: "LookupTableExport"
+  }
+  in_arg {
+    name: "table_handle"
+    description: <<END
+Handle to the table.
+END
+  }
+  out_arg {
+    name: "keys"
+    description: <<END
+Vector of all keys present in the table.
+END
+  }
+  out_arg {
+    name: "values"
+    description: <<END
+Tensor of all values in the table. Indexed in parallel with `keys`.
+END
+  }
+  summary: "Outputs all keys and values in the table."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LookupTableFind.pbtxt b/tensorflow/core/api_def/base_api/api_def_LookupTableFind.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ce1109e7ebb5e55138d5ae0aa22582afe57041fa
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LookupTableFind.pbtxt
@@ -0,0 +1,31 @@
+op {
+  graph_op_name: "LookupTableFind"
+  visibility: SKIP
+  in_arg {
+    name: "table_handle"
+    description: <<END
+Handle to the table.
+END
+  }
+  in_arg {
+    name: "keys"
+    description: <<END
+Any shape.  Keys to look up.
+END
+  }
+  out_arg {
+    name: "values"
+    description: <<END
+Same shape as `keys`.  Values found in the table, or `default_values`
+for missing keys.
+END
+  }
+  summary: "Looks up keys in a table, outputs the corresponding values."
+  description: <<END
+The tensor `keys` must of the same type as the keys of the table.
+The output `values` is of the type of the table values.
+
+The scalar `default_value` is the value output for keys not present in the
+table. It must also be of the same type as the table values.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LookupTableFindV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_LookupTableFindV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..30f69220e8dcad9a89039d157470b0603f2bb73c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LookupTableFindV2.pbtxt
@@ -0,0 +1,33 @@
+op {
+  graph_op_name: "LookupTableFindV2"
+  endpoint {
+    name: "LookupTableFind"
+  }
+  in_arg {
+    name: "table_handle"
+    description: <<END
+Handle to the table.
+END
+  }
+  in_arg {
+    name: "keys"
+    description: <<END
+Any shape.  Keys to look up.
+END
+  }
+  out_arg {
+    name: "values"
+    description: <<END
+Same shape as `keys`.  Values found in the table, or `default_values`
+for missing keys.
+END
+  }
+  summary: "Looks up keys in a table, outputs the corresponding values."
+  description: <<END
+The tensor `keys` must of the same type as the keys of the table.
+The output `values` is of the type of the table values.
+
+The scalar `default_value` is the value output for keys not present in the
+table. It must also be of the same type as the table values.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LookupTableImport.pbtxt b/tensorflow/core/api_def/base_api/api_def_LookupTableImport.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6861c4e97d95e9fdde8ddc7bc1ee87a1ff2837e7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LookupTableImport.pbtxt
@@ -0,0 +1,27 @@
+op {
+  graph_op_name: "LookupTableImport"
+  visibility: SKIP
+  in_arg {
+    name: "table_handle"
+    description: <<END
+Handle to the table.
+END
+  }
+  in_arg {
+    name: "keys"
+    description: <<END
+Any shape.  Keys to look up.
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+Values to associate with keys.
+END
+  }
+  summary: "Replaces the contents of the table with the specified keys and values."
+  description: <<END
+The tensor `keys` must be of the same type as the keys of the table.
+The tensor `values` must be of the type of the table values.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LookupTableImportV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_LookupTableImportV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f39fbc499670076c220dbd3a87c329d0fb28ccd4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LookupTableImportV2.pbtxt
@@ -0,0 +1,29 @@
+op {
+  graph_op_name: "LookupTableImportV2"
+  endpoint {
+    name: "LookupTableImport"
+  }
+  in_arg {
+    name: "table_handle"
+    description: <<END
+Handle to the table.
+END
+  }
+  in_arg {
+    name: "keys"
+    description: <<END
+Any shape.  Keys to look up.
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+Values to associate with keys.
+END
+  }
+  summary: "Replaces the contents of the table with the specified keys and values."
+  description: <<END
+The tensor `keys` must be of the same type as the keys of the table.
+The tensor `values` must be of the type of the table values.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LookupTableInsert.pbtxt b/tensorflow/core/api_def/base_api/api_def_LookupTableInsert.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f07ac2f3db9bdf980eec55726d25bf69df52415e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LookupTableInsert.pbtxt
@@ -0,0 +1,27 @@
+op {
+  graph_op_name: "LookupTableInsert"
+  visibility: SKIP
+  in_arg {
+    name: "table_handle"
+    description: <<END
+Handle to the table.
+END
+  }
+  in_arg {
+    name: "keys"
+    description: <<END
+Any shape.  Keys to look up.
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+Values to associate with keys.
+END
+  }
+  summary: "Updates the table to associates keys with values."
+  description: <<END
+The tensor `keys` must be of the same type as the keys of the table.
+The tensor `values` must be of the type of the table values.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LookupTableInsertV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_LookupTableInsertV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b93e68a5b0deb34955aa23e2f9326c6b8fed8175
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LookupTableInsertV2.pbtxt
@@ -0,0 +1,29 @@
+op {
+  graph_op_name: "LookupTableInsertV2"
+  endpoint {
+    name: "LookupTableInsert"
+  }
+  in_arg {
+    name: "table_handle"
+    description: <<END
+Handle to the table.
+END
+  }
+  in_arg {
+    name: "keys"
+    description: <<END
+Any shape.  Keys to look up.
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+Values to associate with keys.
+END
+  }
+  summary: "Updates the table to associates keys with values."
+  description: <<END
+The tensor `keys` must be of the same type as the keys of the table.
+The tensor `values` must be of the type of the table values.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LookupTableSize.pbtxt b/tensorflow/core/api_def/base_api/api_def_LookupTableSize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d561c45d6279bd45c40009c93831af32cb7b2366
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LookupTableSize.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "LookupTableSize"
+  visibility: SKIP
+  in_arg {
+    name: "table_handle"
+    description: <<END
+Handle to the table.
+END
+  }
+  out_arg {
+    name: "size"
+    description: <<END
+Scalar that contains number of elements in the table.
+END
+  }
+  summary: "Computes the number of elements in the given table."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LookupTableSizeV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_LookupTableSizeV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bf5ab2566397d3b2833577add0828313317f73f6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LookupTableSizeV2.pbtxt
@@ -0,0 +1,19 @@
+op {
+  graph_op_name: "LookupTableSizeV2"
+  endpoint {
+    name: "LookupTableSize"
+  }
+  in_arg {
+    name: "table_handle"
+    description: <<END
+Handle to the table.
+END
+  }
+  out_arg {
+    name: "size"
+    description: <<END
+Scalar that contains number of elements in the table.
+END
+  }
+  summary: "Computes the number of elements in the given table."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_LoopCond.pbtxt b/tensorflow/core/api_def/base_api/api_def_LoopCond.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7b2dbdf4b45df8e87d50b253195a0a8d44b4e5da
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_LoopCond.pbtxt
@@ -0,0 +1,20 @@
+op {
+  graph_op_name: "LoopCond"
+  in_arg {
+    name: "input"
+    description: <<END
+A boolean scalar, representing the branch predicate of the Switch op.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The same tensor as `input`.
+END
+  }
+  summary: "Forwards the input to the output."
+  description: <<END
+This operator represents the loop termination condition used by the
+"pivot" switches of a loop.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_M.pbtxt b/tensorflow/core/api_def/base_api/api_def_M.pbtxt
deleted file mode 100644
index 7295928bad88fe1a341c624b6e47a0d6db9c73e2..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_M.pbtxt
+++ /dev/null
@@ -1,749 +0,0 @@
-op {
-  graph_op_name: "MakeIterator"
-  endpoint {
-    name: "MakeIterator"
-  }
-  summary: "Makes a new iterator from the given `dataset` and stores it in `iterator`."
-  description: <<END
-This operation may be executed multiple times. Each execution will reset the
-iterator in `iterator` to the first element of `dataset`.
-END
-}
-op {
-  graph_op_name: "MapClear"
-  endpoint {
-    name: "MapClear"
-  }
-  summary: "Op removes all elements in the underlying container."
-}
-op {
-  graph_op_name: "MapDataset"
-  endpoint {
-    name: "MapDataset"
-  }
-  summary: "Creates a dataset that applies `f` to the outputs of `input_dataset`."
-}
-op {
-  graph_op_name: "MapIncompleteSize"
-  endpoint {
-    name: "MapIncompleteSize"
-  }
-  summary: "Op returns the number of incomplete elements in the underlying container."
-}
-op {
-  graph_op_name: "MapPeek"
-  endpoint {
-    name: "MapPeek"
-  }
-  summary: "Op peeks at the values at the specified key.  If the"
-  description: <<END
-underlying container does not contain this key
-this op will block until it does.
-END
-}
-op {
-  graph_op_name: "MapSize"
-  endpoint {
-    name: "MapSize"
-  }
-  summary: "Op returns the number of elements in the underlying container."
-}
-op {
-  graph_op_name: "MapStage"
-  endpoint {
-    name: "MapStage"
-  }
-  summary: "Stage (key, values) in the underlying container which behaves like a hashtable."
-}
-op {
-  graph_op_name: "MapUnstage"
-  endpoint {
-    name: "MapUnstage"
-  }
-  summary: "Op removes and returns the values associated with the key"
-  description: <<END
-from the underlying container.   If the underlying container
-does not contain this key, the op will block until it does.
-END
-}
-op {
-  graph_op_name: "MapUnstageNoKey"
-  endpoint {
-    name: "MapUnstageNoKey"
-  }
-  summary: "Op removes and returns a random (key, value)"
-  description: <<END
-from the underlying container.   If the underlying container
-does not contain elements, the op will block until it does.
-END
-}
-op {
-  graph_op_name: "MatMul"
-  endpoint {
-    name: "MatMul"
-  }
-  summary: "Multiply the matrix \"a\" by the matrix \"b\"."
-  description: <<END
-The inputs must be two-dimensional matrices and the inner dimension of
-"a" (after being transposed if transpose_a is true) must match the
-outer dimension of "b" (after being transposed if transposed_b is
-true).
-
-*Note*: The default kernel implementation for MatMul on GPUs uses
-cublas.
-END
-}
-op {
-  graph_op_name: "MatchingFiles"
-  endpoint {
-    name: "MatchingFiles"
-  }
-  summary: "Returns the set of files matching one or more glob patterns."
-  description: <<END
-Note that this routine only supports wildcard characters in the
-basename portion of the pattern, not in the directory portion.
-END
-}
-op {
-  graph_op_name: "MatrixBandPart"
-  endpoint {
-    name: "MatrixBandPart"
-  }
-  summary: "Copy a tensor setting everything outside a central band in each innermost matrix"
-  description: <<END
-to zero.
-
-The `band` part is computed as follows:
-Assume `input` has `k` dimensions `[I, J, K, ..., M, N]`, then the output is a
-tensor with the same shape where
-
-`band[i, j, k, ..., m, n] = in_band(m, n) * input[i, j, k, ..., m, n]`.
-
-The indicator function
-
-`in_band(m, n) = (num_lower < 0 || (m-n) <= num_lower)) &&
-                 (num_upper < 0 || (n-m) <= num_upper)`.
-
-For example:
-
-```
-# if 'input' is [[ 0,  1,  2, 3]
-                 [-1,  0,  1, 2]
-                 [-2, -1,  0, 1]
-                 [-3, -2, -1, 0]],
-
-tf.matrix_band_part(input, 1, -1) ==> [[ 0,  1,  2, 3]
-                                       [-1,  0,  1, 2]
-                                       [ 0, -1,  0, 1]
-                                       [ 0,  0, -1, 0]],
-
-tf.matrix_band_part(input, 2, 1) ==> [[ 0,  1,  0, 0]
-                                      [-1,  0,  1, 0]
-                                      [-2, -1,  0, 1]
-                                      [ 0, -2, -1, 0]]
-```
-
-Useful special cases:
-
-```
- tf.matrix_band_part(input, 0, -1) ==> Upper triangular part.
- tf.matrix_band_part(input, -1, 0) ==> Lower triangular part.
- tf.matrix_band_part(input, 0, 0) ==> Diagonal.
-```
-END
-}
-op {
-  graph_op_name: "MatrixDeterminant"
-  endpoint {
-    name: "MatrixDeterminant"
-  }
-  summary: "Computes the determinant of one or more square matrices."
-  description: <<END
-The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
-form square matrices. The output is a tensor containing the determinants
-for all input submatrices `[..., :, :]`.
-END
-}
-op {
-  graph_op_name: "MatrixDiag"
-  endpoint {
-    name: "MatrixDiag"
-  }
-  summary: "Returns a batched diagonal tensor with a given batched diagonal values."
-  description: <<END
-Given a `diagonal`, this operation returns a tensor with the `diagonal` and
-everything else padded with zeros. The diagonal is computed as follows:
-
-Assume `diagonal` has `k` dimensions `[I, J, K, ..., N]`, then the output is a
-tensor of rank `k+1` with dimensions [I, J, K, ..., N, N]` where:
-
-`output[i, j, k, ..., m, n] = 1{m=n} * diagonal[i, j, k, ..., n]`.
-
-For example:
-
-```
-# 'diagonal' is [[1, 2, 3, 4], [5, 6, 7, 8]]
-
-and diagonal.shape = (2, 4)
-
-tf.matrix_diag(diagonal) ==> [[[1, 0, 0, 0]
-                                     [0, 2, 0, 0]
-                                     [0, 0, 3, 0]
-                                     [0, 0, 0, 4]],
-                                    [[5, 0, 0, 0]
-                                     [0, 6, 0, 0]
-                                     [0, 0, 7, 0]
-                                     [0, 0, 0, 8]]]
-
-which has shape (2, 4, 4)
-```
-END
-}
-op {
-  graph_op_name: "MatrixDiagPart"
-  endpoint {
-    name: "MatrixDiagPart"
-  }
-  summary: "Returns the batched diagonal part of a batched tensor."
-  description: <<END
-This operation returns a tensor with the `diagonal` part
-of the batched `input`. The `diagonal` part is computed as follows:
-
-Assume `input` has `k` dimensions `[I, J, K, ..., M, N]`, then the output is a
-tensor of rank `k - 1` with dimensions `[I, J, K, ..., min(M, N)]` where:
-
-`diagonal[i, j, k, ..., n] = input[i, j, k, ..., n, n]`.
-
-The input must be at least a matrix.
-
-For example:
-
-```
-# 'input' is [[[1, 0, 0, 0]
-               [0, 2, 0, 0]
-               [0, 0, 3, 0]
-               [0, 0, 0, 4]],
-              [[5, 0, 0, 0]
-               [0, 6, 0, 0]
-               [0, 0, 7, 0]
-               [0, 0, 0, 8]]]
-
-and input.shape = (2, 4, 4)
-
-tf.matrix_diag_part(input) ==> [[1, 2, 3, 4], [5, 6, 7, 8]]
-
-which has shape (2, 4)
-```
-END
-}
-op {
-  graph_op_name: "MatrixInverse"
-  endpoint {
-    name: "MatrixInverse"
-  }
-  summary: "Computes the inverse of one or more square invertible matrices or their"
-  description: <<END
-adjoints (conjugate transposes).
-
-The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
-form square matrices. The output is a tensor of the same shape as the input
-containing the inverse for all input submatrices `[..., :, :]`.
-
-The op uses LU decomposition with partial pivoting to compute the inverses.
-
-If a matrix is not invertible there is no guarantee what the op does. It
-may detect the condition and raise an exception or it may simply return a
-garbage result.
-END
-}
-op {
-  graph_op_name: "MatrixSetDiag"
-  endpoint {
-    name: "MatrixSetDiag"
-  }
-  summary: "Returns a batched matrix tensor with new batched diagonal values."
-  description: <<END
-Given `input` and `diagonal`, this operation returns a tensor with the
-same shape and values as `input`, except for the main diagonal of the
-innermost matrices.  These will be overwritten by the values in `diagonal`.
-
-The output is computed as follows:
-
-Assume `input` has `k+1` dimensions `[I, J, K, ..., M, N]` and `diagonal` has
-`k` dimensions `[I, J, K, ..., min(M, N)]`.  Then the output is a
-tensor of rank `k+1` with dimensions `[I, J, K, ..., M, N]` where:
-
-  * `output[i, j, k, ..., m, n] = diagonal[i, j, k, ..., n]` for `m == n`.
-  * `output[i, j, k, ..., m, n] = input[i, j, k, ..., m, n]` for `m != n`.
-END
-}
-op {
-  graph_op_name: "MatrixSolve"
-  endpoint {
-    name: "MatrixSolve"
-  }
-  summary: "Solves systems of linear equations."
-  description: <<END
-`Matrix` is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
-form square matrices. `Rhs` is a tensor of shape `[..., M, K]`. The `output` is
-a tensor shape `[..., M, K]`.  If `adjoint` is `False` then each output matrix
-satisfies `matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]`.
-If `adjoint` is `True` then each output matrix satisfies
-`adjoint(matrix[..., :, :]) * output[..., :, :] = rhs[..., :, :]`.
-END
-}
-op {
-  graph_op_name: "MatrixSolveLs"
-  endpoint {
-    name: "MatrixSolveLs"
-  }
-  summary: "Solves one or more linear least-squares problems."
-  description: <<END
-`matrix` is a tensor of shape `[..., M, N]` whose inner-most 2 dimensions
-form real or complex matrices of size `[M, N]`. `Rhs` is a tensor of the same
-type as `matrix` and shape `[..., M, K]`.
-The output is a tensor shape `[..., N, K]` where each output matrix solves
-each of the equations
-`matrix[..., :, :]` * `output[..., :, :]` = `rhs[..., :, :]`
-in the least squares sense.
-
-We use the following notation for (complex) matrix and right-hand sides
-in the batch:
-
-`matrix`=\\(A \in \mathbb{C}^{m \times n}\\),
-`rhs`=\\(B  \in \mathbb{C}^{m \times k}\\),
-`output`=\\(X  \in \mathbb{C}^{n \times k}\\),
-`l2_regularizer`=\\(\lambda \in \mathbb{R}\\).
-
-If `fast` is `True`, then the solution is computed by solving the normal
-equations using Cholesky decomposition. Specifically, if \\(m \ge n\\) then
-\\(X = (A^H A + \lambda I)^{-1} A^H B\\), which solves the least-squares
-problem \\(X = \mathrm{argmin}_{Z \in \Re^{n \times k} } ||A Z - B||_F^2 +
-\lambda ||Z||_F^2\\). If \\(m \lt n\\) then `output` is computed as
-\\(X = A^H (A A^H + \lambda I)^{-1} B\\), which (for \\(\lambda = 0\\)) is the
-minimum-norm solution to the under-determined linear system, i.e.
-\\(X = \mathrm{argmin}_{Z \in \mathbb{C}^{n \times k} } ||Z||_F^2 \\),
-subject to \\(A Z = B\\). Notice that the fast path is only numerically stable
-when \\(A\\) is numerically full rank and has a condition number
-\\(\mathrm{cond}(A) \lt \frac{1}{\sqrt{\epsilon_{mach} } }\\) or\\(\lambda\\) is
-sufficiently large.
-
-If `fast` is `False` an algorithm based on the numerically robust complete
-orthogonal decomposition is used. This computes the minimum-norm
-least-squares solution, even when \\(A\\) is rank deficient. This path is
-typically 6-7 times slower than the fast path. If `fast` is `False` then
-`l2_regularizer` is ignored.
-END
-}
-op {
-  graph_op_name: "MatrixTriangularSolve"
-  endpoint {
-    name: "MatrixTriangularSolve"
-  }
-  summary: "Solves systems of linear equations with upper or lower triangular matrices by"
-  description: <<END
-backsubstitution.
-
-`matrix` is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions form
-square matrices. If `lower` is `True` then the strictly upper triangular part
-of each inner-most matrix is assumed to be zero and not accessed.
-If `lower` is False then the strictly lower triangular part of each inner-most
-matrix is assumed to be zero and not accessed.
-`rhs` is a tensor of shape `[..., M, K]`.
-
-The output is a tensor of shape `[..., M, K]`. If `adjoint` is
-`True` then the innermost matrices in `output` satisfy matrix equations
-`matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]`.
-If `adjoint` is `False` then the strictly then the  innermost matrices in
-`output` satisfy matrix equations
-`adjoint(matrix[..., i, k]) * output[..., k, j] = rhs[..., i, j]`.
-END
-}
-op {
-  graph_op_name: "Max"
-  endpoint {
-    name: "Max"
-  }
-  summary: "Computes the maximum of elements across dimensions of a tensor."
-  description: <<END
-Reduces `input` along the dimensions given in `reduction_indices`. Unless
-`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-`reduction_indices`. If `keep_dims` is true, the reduced dimensions are
-retained with length 1.
-END
-}
-op {
-  graph_op_name: "MaxPool"
-  endpoint {
-    name: "MaxPool"
-  }
-  summary: "Performs max pooling on the input."
-}
-op {
-  graph_op_name: "MaxPool3D"
-  endpoint {
-    name: "MaxPool3D"
-  }
-  summary: "Performs 3D max pooling on the input."
-}
-op {
-  graph_op_name: "MaxPool3DGrad"
-  endpoint {
-    name: "MaxPool3DGrad"
-  }
-  summary: "Computes gradients of max pooling function."
-}
-op {
-  graph_op_name: "MaxPool3DGradGrad"
-  endpoint {
-    name: "MaxPool3DGradGrad"
-  }
-  summary: "Computes second-order gradients of the maxpooling function."
-}
-op {
-  graph_op_name: "MaxPoolGrad"
-  endpoint {
-    name: "MaxPoolGrad"
-  }
-  summary: "Computes gradients of the maxpooling function."
-}
-op {
-  graph_op_name: "MaxPoolGradGrad"
-  endpoint {
-    name: "MaxPoolGradGrad"
-  }
-  summary: "Computes second-order gradients of the maxpooling function."
-}
-op {
-  graph_op_name: "MaxPoolGradGradV2"
-  endpoint {
-    name: "MaxPoolGradGradV2"
-  }
-  summary: "Computes second-order gradients of the maxpooling function."
-}
-op {
-  graph_op_name: "MaxPoolGradGradWithArgmax"
-  endpoint {
-    name: "MaxPoolGradGradWithArgmax"
-  }
-  summary: "Computes second-order gradients of the maxpooling function."
-}
-op {
-  graph_op_name: "MaxPoolGradV2"
-  endpoint {
-    name: "MaxPoolGradV2"
-  }
-  summary: "Computes gradients of the maxpooling function."
-}
-op {
-  graph_op_name: "MaxPoolGradWithArgmax"
-  endpoint {
-    name: "MaxPoolGradWithArgmax"
-  }
-  summary: "Computes gradients of the maxpooling function."
-}
-op {
-  graph_op_name: "MaxPoolV2"
-  endpoint {
-    name: "MaxPoolV2"
-  }
-  summary: "Performs max pooling on the input."
-}
-op {
-  graph_op_name: "MaxPoolWithArgmax"
-  endpoint {
-    name: "MaxPoolWithArgmax"
-  }
-  summary: "Performs max pooling on the input and outputs both max values and indices."
-  description: <<END
-The indices in `argmax` are flattened, so that a maximum value at position
-`[b, y, x, c]` becomes flattened index
-`((b * height + y) * width + x) * channels + c`.
-
-The indices returned are always in `[0, height) x [0, width)` before flattening,
-even if padding is involved and the mathematically correct answer is outside
-(either negative or too large).  This is a bug, but fixing it is difficult to do
-in a safe backwards compatible way, especially due to flattening.
-END
-}
-op {
-  graph_op_name: "Maximum"
-  endpoint {
-    name: "Maximum"
-  }
-  summary: "Returns the max of x and y (i.e. x > y ? x : y) element-wise."
-  description: <<END
-*NOTE*: `Maximum` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "Mean"
-  endpoint {
-    name: "Mean"
-  }
-  summary: "Computes the mean of elements across dimensions of a tensor."
-  description: <<END
-Reduces `input` along the dimensions given in `reduction_indices`. Unless
-`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-`reduction_indices`. If `keep_dims` is true, the reduced dimensions are
-retained with length 1.
-END
-}
-op {
-  graph_op_name: "Merge"
-  endpoint {
-    name: "Merge"
-  }
-  summary: "Forwards the value of an available tensor from `inputs` to `output`."
-  description: <<END
-`Merge` waits for at least one of the tensors in `inputs` to become available.
-It is usually combined with `Switch` to implement branching.
-
-`Merge` forwards the first tensor to become available to `output`, and sets
-`value_index` to its index in `inputs`.
-END
-}
-op {
-  graph_op_name: "MergeSummary"
-  endpoint {
-    name: "MergeSummary"
-  }
-  summary: "Merges summaries."
-  description: <<END
-This op creates a
-[`Summary`](https://www.tensorflow.org/code/tensorflow/core/framework/summary.proto)
-protocol buffer that contains the union of all the values in the input
-summaries.
-
-When the Op is run, it reports an `InvalidArgument` error if multiple values
-in the summaries to merge use the same tag.
-END
-}
-op {
-  graph_op_name: "MergeV2Checkpoints"
-  endpoint {
-    name: "MergeV2Checkpoints"
-  }
-  summary: "V2 format specific: merges the metadata files of sharded checkpoints.  The"
-  description: <<END
-result is one logical checkpoint, with one physical metadata file and renamed
-data files.
-
-Intended for "grouping" multiple checkpoints in a sharded checkpoint setup.
-
-If delete_old_dirs is true, attempts to delete recursively the dirname of each
-path in the input checkpoint_prefixes.  This is useful when those paths are non
-user-facing temporary locations.
-END
-}
-op {
-  graph_op_name: "Mfcc"
-  endpoint {
-    name: "Mfcc"
-  }
-  summary: "Transforms a spectrogram into a form that\'s useful for speech recognition."
-  description: <<END
-Mel Frequency Cepstral Coefficients are a way of representing audio data that's
-been effective as an input feature for machine learning. They are created by
-taking the spectrum of a spectrogram (a 'cepstrum'), and discarding some of the
-higher frequencies that are less significant to the human ear. They have a long
-history in the speech recognition world, and https://en.wikipedia.org/wiki/Mel-frequency_cepstrum
-is a good resource to learn more.
-END
-}
-op {
-  graph_op_name: "Min"
-  endpoint {
-    name: "Min"
-  }
-  summary: "Computes the minimum of elements across dimensions of a tensor."
-  description: <<END
-Reduces `input` along the dimensions given in `reduction_indices`. Unless
-`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-`reduction_indices`. If `keep_dims` is true, the reduced dimensions are
-retained with length 1.
-END
-}
-op {
-  graph_op_name: "Minimum"
-  endpoint {
-    name: "Minimum"
-  }
-  summary: "Returns the min of x and y (i.e. x < y ? x : y) element-wise."
-  description: <<END
-*NOTE*: `Minimum` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "MirrorPad"
-  endpoint {
-    name: "MirrorPad"
-  }
-  summary: "Pads a tensor with mirrored values."
-  description: <<END
-This operation pads a `input` with mirrored values according to the `paddings`
-you specify. `paddings` is an integer tensor with shape `[n, 2]`, where n is
-the rank of `input`. For each dimension D of `input`, `paddings[D, 0]` indicates
-how many values to add before the contents of `input` in that dimension, and
-`paddings[D, 1]` indicates how many values to add after the contents of `input`
-in that dimension. Both `paddings[D, 0]` and `paddings[D, 1]` must be no greater
-than `input.dim_size(D)` (or `input.dim_size(D) - 1`) if `copy_border` is true
-(if false, respectively).
-
-The padded size of each dimension D of the output is:
-
-`paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
-
-For example:
-
-```
-# 't' is [[1, 2, 3], [4, 5, 6]].
-# 'paddings' is [[1, 1]], [2, 2]].
-# 'mode' is SYMMETRIC.
-# rank of 't' is 2.
-pad(t, paddings) ==> [[2, 1, 1, 2, 3, 3, 2]
-                      [2, 1, 1, 2, 3, 3, 2]
-                      [5, 4, 4, 5, 6, 6, 5]
-                      [5, 4, 4, 5, 6, 6, 5]]
-```
-END
-}
-op {
-  graph_op_name: "MirrorPadGrad"
-  endpoint {
-    name: "MirrorPadGrad"
-  }
-  summary: "Gradient op for `MirrorPad` op. This op folds a mirror-padded tensor."
-  description: <<END
-This operation folds the padded areas of `input` by `MirrorPad` according to the
-`paddings` you specify. `paddings` must be the same as `paddings` argument
-given to the corresponding `MirrorPad` op.
-
-The folded size of each dimension D of the output is:
-
-`input.dim_size(D) - paddings(D, 0) - paddings(D, 1)`
-
-For example:
-
-```
-# 't' is [[1, 2, 3], [4, 5, 6], [7, 8, 9]].
-# 'paddings' is [[0, 1]], [0, 1]].
-# 'mode' is SYMMETRIC.
-# rank of 't' is 2.
-pad(t, paddings) ==> [[ 1,  5]
-                      [11, 28]]
-```
-END
-}
-op {
-  graph_op_name: "Mod"
-  endpoint {
-    name: "Mod"
-  }
-  summary: "Returns element-wise remainder of division. This emulates C semantics in that"
-  description: <<END
-the result here is consistent with a truncating divide. E.g. `truncate(x / y) *
-y + truncate_mod(x, y) = x`.
-
-*NOTE*: `Mod` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "Mul"
-  endpoint {
-    name: "Mul"
-  }
-  summary: "Returns x * y element-wise."
-  description: <<END
-*NOTE*: `Mul` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "Multinomial"
-  endpoint {
-    name: "Multinomial"
-  }
-  summary: "Draws samples from a multinomial distribution."
-}
-op {
-  graph_op_name: "MutableDenseHashTable"
-  endpoint {
-    name: "MutableDenseHashTable"
-  }
-  summary: "Creates an empty hash table that uses tensors as the backing store."
-  description: <<END
-It uses "open addressing" with quadratic reprobing to resolve
-collisions.
-
-This op creates a mutable hash table, specifying the type of its keys and
-values. Each value must be a scalar. Data can be inserted into the table using
-the insert operations. It does not support the initialization operation.
-END
-}
-op {
-  graph_op_name: "MutableDenseHashTableV2"
-  endpoint {
-    name: "MutableDenseHashTableV2"
-  }
-  summary: "Creates an empty hash table that uses tensors as the backing store."
-  description: <<END
-It uses "open addressing" with quadratic reprobing to resolve
-collisions.
-
-This op creates a mutable hash table, specifying the type of its keys and
-values. Each value must be a scalar. Data can be inserted into the table using
-the insert operations. It does not support the initialization operation.
-END
-}
-op {
-  graph_op_name: "MutableHashTable"
-  endpoint {
-    name: "MutableHashTable"
-  }
-  summary: "Creates an empty hash table."
-  description: <<END
-This op creates a mutable hash table, specifying the type of its keys and
-values. Each value must be a scalar. Data can be inserted into the table using
-the insert operations. It does not support the initialization operation.
-END
-}
-op {
-  graph_op_name: "MutableHashTableOfTensors"
-  endpoint {
-    name: "MutableHashTableOfTensors"
-  }
-  summary: "Creates an empty hash table."
-  description: <<END
-This op creates a mutable hash table, specifying the type of its keys and
-values. Each value must be a vector. Data can be inserted into the table using
-the insert operations. It does not support the initialization operation.
-END
-}
-op {
-  graph_op_name: "MutableHashTableOfTensorsV2"
-  endpoint {
-    name: "MutableHashTableOfTensorsV2"
-  }
-  summary: "Creates an empty hash table."
-  description: <<END
-This op creates a mutable hash table, specifying the type of its keys and
-values. Each value must be a vector. Data can be inserted into the table using
-the insert operations. It does not support the initialization operation.
-END
-}
-op {
-  graph_op_name: "MutableHashTableV2"
-  endpoint {
-    name: "MutableHashTableV2"
-  }
-  summary: "Creates an empty hash table."
-  description: <<END
-This op creates a mutable hash table, specifying the type of its keys and
-values. Each value must be a scalar. Data can be inserted into the table using
-the insert operations. It does not support the initialization operation.
-END
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_MakeIterator.pbtxt b/tensorflow/core/api_def/base_api/api_def_MakeIterator.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..921ea86a4bc983e4da8a7bd130571b0d64680a61
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MakeIterator.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "MakeIterator"
+  summary: "Makes a new iterator from the given `dataset` and stores it in `iterator`."
+  description: <<END
+This operation may be executed multiple times. Each execution will reset the
+iterator in `iterator` to the first element of `dataset`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MapAndBatchDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_MapAndBatchDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bf544703de559900317f71eaf5936221ac62080e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MapAndBatchDataset.pbtxt
@@ -0,0 +1,26 @@
+op {
+  graph_op_name: "MapAndBatchDataset"
+  in_arg {
+    name: "batch_size"
+    description: <<END
+A scalar representing the number of elements to accumulate in a
+batch. It determines the number of concurrent invocations of `f` that process
+elements from `input_dataset` in parallel.
+END
+  }
+  in_arg {
+    name: "num_parallel_batches"
+    description: <<END
+A scalar representing the number of batches to create in
+parallel. Processing multiple batches in parallel benefits workloads prone to
+stragglers.
+END
+  }
+  summary: "Creates a dataset that applies `f` to the outputs of `input_dataset` and then"
+  description: <<END
+batches `batch_size` of them.
+
+Unlike a "MapDataset", which applies `f` sequentially, this dataset invokes up
+to `batch_size * num_parallel_batches` copies of `f` in parallel.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MapClear.pbtxt b/tensorflow/core/api_def/base_api/api_def_MapClear.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6c3c2d48b0c5996b40cc9e66bb1a7a1d50db296b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MapClear.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MapClear"
+  summary: "Op removes all elements in the underlying container."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MapDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_MapDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..76d63ec2478e07d5af09754dc63994841119fa56
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MapDataset.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MapDataset"
+  summary: "Creates a dataset that applies `f` to the outputs of `input_dataset`."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MapIncompleteSize.pbtxt b/tensorflow/core/api_def/base_api/api_def_MapIncompleteSize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bd63305ac205208c496d9dd0d7b6283d1104bbc0
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MapIncompleteSize.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MapIncompleteSize"
+  summary: "Op returns the number of incomplete elements in the underlying container."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MapPeek.pbtxt b/tensorflow/core/api_def/base_api/api_def_MapPeek.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..80eb6d5943cbcfc15dad585e595cc33800420ecc
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MapPeek.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "MapPeek"
+  summary: "Op peeks at the values at the specified key.  If the"
+  description: <<END
+underlying container does not contain this key
+this op will block until it does.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MapSize.pbtxt b/tensorflow/core/api_def/base_api/api_def_MapSize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9412019f595d350eac4ac0402f6ad1a33a408acf
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MapSize.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MapSize"
+  summary: "Op returns the number of elements in the underlying container."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MapStage.pbtxt b/tensorflow/core/api_def/base_api/api_def_MapStage.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..555fe538ef3fc1b78ec6cc1e1e524371e1591bc6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MapStage.pbtxt
@@ -0,0 +1,37 @@
+op {
+  graph_op_name: "MapStage"
+  in_arg {
+    name: "key"
+    description: <<END
+int64
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+a list of tensors
+dtypes A list of data types that inserted values should adhere to.
+END
+  }
+  attr {
+    name: "capacity"
+    description: <<END
+Maximum number of elements in the Staging Area. If > 0, inserts
+on the container will block when the capacity is reached.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this queue is placed in the given container. Otherwise,
+a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+It is necessary to match this name to the matching Unstage Op.
+END
+  }
+  summary: "Stage (key, values) in the underlying container which behaves like a hashtable."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MapUnstage.pbtxt b/tensorflow/core/api_def/base_api/api_def_MapUnstage.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..29a10cf9282a73a2b59f36897316739e435bf09f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MapUnstage.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "MapUnstage"
+  summary: "Op removes and returns the values associated with the key"
+  description: <<END
+from the underlying container.   If the underlying container
+does not contain this key, the op will block until it does.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MapUnstageNoKey.pbtxt b/tensorflow/core/api_def/base_api/api_def_MapUnstageNoKey.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b9da7e65d771871c6dae59a976f8949058d60ed4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MapUnstageNoKey.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "MapUnstageNoKey"
+  summary: "Op removes and returns a random (key, value)"
+  description: <<END
+from the underlying container.   If the underlying container
+does not contain elements, the op will block until it does.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MatMul.pbtxt b/tensorflow/core/api_def/base_api/api_def_MatMul.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bdc55e81ae1f45276cf55ed68a9cdce7c83327f9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MatMul.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "MatMul"
+  attr {
+    name: "transpose_a"
+    description: <<END
+If true, "a" is transposed before multiplication.
+END
+  }
+  attr {
+    name: "transpose_b"
+    description: <<END
+If true, "b" is transposed before multiplication.
+END
+  }
+  summary: "Multiply the matrix \"a\" by the matrix \"b\"."
+  description: <<END
+The inputs must be two-dimensional matrices and the inner dimension of
+"a" (after being transposed if transpose_a is true) must match the
+outer dimension of "b" (after being transposed if transposed_b is
+true).
+
+*Note*: The default kernel implementation for MatMul on GPUs uses
+cublas.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MatchingFiles.pbtxt b/tensorflow/core/api_def/base_api/api_def_MatchingFiles.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8da76684e5d360dd642167100b04543e93beed0a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MatchingFiles.pbtxt
@@ -0,0 +1,20 @@
+op {
+  graph_op_name: "MatchingFiles"
+  in_arg {
+    name: "pattern"
+    description: <<END
+Shell wildcard pattern(s). Scalar or vector of type string.
+END
+  }
+  out_arg {
+    name: "filenames"
+    description: <<END
+A vector of matching filenames.
+END
+  }
+  summary: "Returns the set of files matching one or more glob patterns."
+  description: <<END
+Note that this routine only supports wildcard characters in the
+basename portion of the pattern, not in the directory portion.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MatrixBandPart.pbtxt b/tensorflow/core/api_def/base_api/api_def_MatrixBandPart.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..eaf3d28437beb8a3767d13fca57942b46ca62699
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MatrixBandPart.pbtxt
@@ -0,0 +1,71 @@
+op {
+  graph_op_name: "MatrixBandPart"
+  in_arg {
+    name: "input"
+    description: <<END
+Rank `k` tensor.
+END
+  }
+  in_arg {
+    name: "num_lower"
+    description: <<END
+0-D tensor. Number of subdiagonals to keep. If negative, keep entire
+lower triangle.
+END
+  }
+  in_arg {
+    name: "num_upper"
+    description: <<END
+0-D tensor. Number of superdiagonals to keep. If negative, keep
+entire upper triangle.
+END
+  }
+  out_arg {
+    name: "band"
+    description: <<END
+Rank `k` tensor of the same shape as input. The extracted banded tensor.
+END
+  }
+  summary: "Copy a tensor setting everything outside a central band in each innermost matrix"
+  description: <<END
+to zero.
+
+The `band` part is computed as follows:
+Assume `input` has `k` dimensions `[I, J, K, ..., M, N]`, then the output is a
+tensor with the same shape where
+
+`band[i, j, k, ..., m, n] = in_band(m, n) * input[i, j, k, ..., m, n]`.
+
+The indicator function
+
+`in_band(m, n) = (num_lower < 0 || (m-n) <= num_lower)) &&
+                 (num_upper < 0 || (n-m) <= num_upper)`.
+
+For example:
+
+```
+# if 'input' is [[ 0,  1,  2, 3]
+                 [-1,  0,  1, 2]
+                 [-2, -1,  0, 1]
+                 [-3, -2, -1, 0]],
+
+tf.matrix_band_part(input, 1, -1) ==> [[ 0,  1,  2, 3]
+                                       [-1,  0,  1, 2]
+                                       [ 0, -1,  0, 1]
+                                       [ 0,  0, -1, 0]],
+
+tf.matrix_band_part(input, 2, 1) ==> [[ 0,  1,  0, 0]
+                                      [-1,  0,  1, 0]
+                                      [-2, -1,  0, 1]
+                                      [ 0, -2, -1, 0]]
+```
+
+Useful special cases:
+
+```
+ tf.matrix_band_part(input, 0, -1) ==> Upper triangular part.
+ tf.matrix_band_part(input, -1, 0) ==> Lower triangular part.
+ tf.matrix_band_part(input, 0, 0) ==> Diagonal.
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MatrixDeterminant.pbtxt b/tensorflow/core/api_def/base_api/api_def_MatrixDeterminant.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0acfee2a3097f11e3820c4ab82d7c0520bc5ac25
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MatrixDeterminant.pbtxt
@@ -0,0 +1,21 @@
+op {
+  graph_op_name: "MatrixDeterminant"
+  in_arg {
+    name: "input"
+    description: <<END
+Shape is `[..., M, M]`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Shape is `[...]`.
+END
+  }
+  summary: "Computes the determinant of one or more square matrices."
+  description: <<END
+The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+form square matrices. The output is a tensor containing the determinants
+for all input submatrices `[..., :, :]`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MatrixDiag.pbtxt b/tensorflow/core/api_def/base_api/api_def_MatrixDiag.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..59f8902d54c25ed2fcca11b3d1421fe637d9184c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MatrixDiag.pbtxt
@@ -0,0 +1,44 @@
+op {
+  graph_op_name: "MatrixDiag"
+  in_arg {
+    name: "diagonal"
+    description: <<END
+Rank `k`, where `k >= 1`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Rank `k+1`, with `output.shape = diagonal.shape + [diagonal.shape[-1]]`.
+END
+  }
+  summary: "Returns a batched diagonal tensor with a given batched diagonal values."
+  description: <<END
+Given a `diagonal`, this operation returns a tensor with the `diagonal` and
+everything else padded with zeros. The diagonal is computed as follows:
+
+Assume `diagonal` has `k` dimensions `[I, J, K, ..., N]`, then the output is a
+tensor of rank `k+1` with dimensions [I, J, K, ..., N, N]` where:
+
+`output[i, j, k, ..., m, n] = 1{m=n} * diagonal[i, j, k, ..., n]`.
+
+For example:
+
+```
+# 'diagonal' is [[1, 2, 3, 4], [5, 6, 7, 8]]
+
+and diagonal.shape = (2, 4)
+
+tf.matrix_diag(diagonal) ==> [[[1, 0, 0, 0]
+                                     [0, 2, 0, 0]
+                                     [0, 0, 3, 0]
+                                     [0, 0, 0, 4]],
+                                    [[5, 0, 0, 0]
+                                     [0, 6, 0, 0]
+                                     [0, 0, 7, 0]
+                                     [0, 0, 0, 8]]]
+
+which has shape (2, 4, 4)
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MatrixDiagPart.pbtxt b/tensorflow/core/api_def/base_api/api_def_MatrixDiagPart.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2c2dbc7f262693e7af2c8ab703e0bc034cc7f6ab
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MatrixDiagPart.pbtxt
@@ -0,0 +1,47 @@
+op {
+  graph_op_name: "MatrixDiagPart"
+  in_arg {
+    name: "input"
+    description: <<END
+Rank `k` tensor where `k >= 2`.
+END
+  }
+  out_arg {
+    name: "diagonal"
+    description: <<END
+The extracted diagonal(s) having shape
+`diagonal.shape = input.shape[:-2] + [min(input.shape[-2:])]`.
+END
+  }
+  summary: "Returns the batched diagonal part of a batched tensor."
+  description: <<END
+This operation returns a tensor with the `diagonal` part
+of the batched `input`. The `diagonal` part is computed as follows:
+
+Assume `input` has `k` dimensions `[I, J, K, ..., M, N]`, then the output is a
+tensor of rank `k - 1` with dimensions `[I, J, K, ..., min(M, N)]` where:
+
+`diagonal[i, j, k, ..., n] = input[i, j, k, ..., n, n]`.
+
+The input must be at least a matrix.
+
+For example:
+
+```
+# 'input' is [[[1, 0, 0, 0]
+               [0, 2, 0, 0]
+               [0, 0, 3, 0]
+               [0, 0, 0, 4]],
+              [[5, 0, 0, 0]
+               [0, 6, 0, 0]
+               [0, 0, 7, 0]
+               [0, 0, 0, 8]]]
+
+and input.shape = (2, 4, 4)
+
+tf.matrix_diag_part(input) ==> [[1, 2, 3, 4], [5, 6, 7, 8]]
+
+which has shape (2, 4)
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MatrixInverse.pbtxt b/tensorflow/core/api_def/base_api/api_def_MatrixInverse.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..25eca0c766bf33305665b12dba2c9f1ba2cac1a3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MatrixInverse.pbtxt
@@ -0,0 +1,33 @@
+op {
+  graph_op_name: "MatrixInverse"
+  in_arg {
+    name: "input"
+    description: <<END
+Shape is `[..., M, M]`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Shape is `[..., M, M]`.
+
+@compatibility(numpy)
+Equivalent to np.linalg.inv
+@end_compatibility
+END
+  }
+  summary: "Computes the inverse of one or more square invertible matrices or their"
+  description: <<END
+adjoints (conjugate transposes).
+
+The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+form square matrices. The output is a tensor of the same shape as the input
+containing the inverse for all input submatrices `[..., :, :]`.
+
+The op uses LU decomposition with partial pivoting to compute the inverses.
+
+If a matrix is not invertible there is no guarantee what the op does. It
+may detect the condition and raise an exception or it may simply return a
+garbage result.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MatrixSetDiag.pbtxt b/tensorflow/core/api_def/base_api/api_def_MatrixSetDiag.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5190902d7e1964344a0966c10ed757795b818818
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MatrixSetDiag.pbtxt
@@ -0,0 +1,36 @@
+op {
+  graph_op_name: "MatrixSetDiag"
+  in_arg {
+    name: "input"
+    description: <<END
+Rank `k+1`, where `k >= 1`.
+END
+  }
+  in_arg {
+    name: "diagonal"
+    description: <<END
+Rank `k`, where `k >= 1`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Rank `k+1`, with `output.shape = input.shape`.
+END
+  }
+  summary: "Returns a batched matrix tensor with new batched diagonal values."
+  description: <<END
+Given `input` and `diagonal`, this operation returns a tensor with the
+same shape and values as `input`, except for the main diagonal of the
+innermost matrices.  These will be overwritten by the values in `diagonal`.
+
+The output is computed as follows:
+
+Assume `input` has `k+1` dimensions `[I, J, K, ..., M, N]` and `diagonal` has
+`k` dimensions `[I, J, K, ..., min(M, N)]`.  Then the output is a
+tensor of rank `k+1` with dimensions `[I, J, K, ..., M, N]` where:
+
+  * `output[i, j, k, ..., m, n] = diagonal[i, j, k, ..., n]` for `m == n`.
+  * `output[i, j, k, ..., m, n] = input[i, j, k, ..., m, n]` for `m != n`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MatrixSolve.pbtxt b/tensorflow/core/api_def/base_api/api_def_MatrixSolve.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d3b1216d404e3dce12996fdc9a91e7336476dd82
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MatrixSolve.pbtxt
@@ -0,0 +1,37 @@
+op {
+  graph_op_name: "MatrixSolve"
+  in_arg {
+    name: "matrix"
+    description: <<END
+Shape is `[..., M, M]`.
+END
+  }
+  in_arg {
+    name: "rhs"
+    description: <<END
+Shape is `[..., M, K]`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Shape is `[..., M, K]`.
+END
+  }
+  attr {
+    name: "adjoint"
+    description: <<END
+Boolean indicating whether to solve with `matrix` or its (block-wise)
+adjoint.
+END
+  }
+  summary: "Solves systems of linear equations."
+  description: <<END
+`Matrix` is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+form square matrices. `Rhs` is a tensor of shape `[..., M, K]`. The `output` is
+a tensor shape `[..., M, K]`.  If `adjoint` is `False` then each output matrix
+satisfies `matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]`.
+If `adjoint` is `True` then each output matrix satisfies
+`adjoint(matrix[..., :, :]) * output[..., :, :] = rhs[..., :, :]`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MatrixSolveLs.pbtxt b/tensorflow/core/api_def/base_api/api_def_MatrixSolveLs.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..51d91399f8a53325b03e67e643c1375c2bd7cf22
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MatrixSolveLs.pbtxt
@@ -0,0 +1,68 @@
+op {
+  graph_op_name: "MatrixSolveLs"
+  in_arg {
+    name: "matrix"
+    description: <<END
+Shape is `[..., M, N]`.
+END
+  }
+  in_arg {
+    name: "rhs"
+    description: <<END
+Shape is `[..., M, K]`.
+END
+  }
+  in_arg {
+    name: "l2_regularizer"
+    description: <<END
+Scalar tensor.
+
+@compatibility(numpy)
+Equivalent to np.linalg.lstsq
+@end_compatibility
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Shape is `[..., N, K]`.
+END
+  }
+  summary: "Solves one or more linear least-squares problems."
+  description: <<END
+`matrix` is a tensor of shape `[..., M, N]` whose inner-most 2 dimensions
+form real or complex matrices of size `[M, N]`. `Rhs` is a tensor of the same
+type as `matrix` and shape `[..., M, K]`.
+The output is a tensor shape `[..., N, K]` where each output matrix solves
+each of the equations
+`matrix[..., :, :]` * `output[..., :, :]` = `rhs[..., :, :]`
+in the least squares sense.
+
+We use the following notation for (complex) matrix and right-hand sides
+in the batch:
+
+`matrix`=\\(A \in \mathbb{C}^{m \times n}\\),
+`rhs`=\\(B  \in \mathbb{C}^{m \times k}\\),
+`output`=\\(X  \in \mathbb{C}^{n \times k}\\),
+`l2_regularizer`=\\(\lambda \in \mathbb{R}\\).
+
+If `fast` is `True`, then the solution is computed by solving the normal
+equations using Cholesky decomposition. Specifically, if \\(m \ge n\\) then
+\\(X = (A^H A + \lambda I)^{-1} A^H B\\), which solves the least-squares
+problem \\(X = \mathrm{argmin}_{Z \in \Re^{n \times k} } ||A Z - B||_F^2 +
+\lambda ||Z||_F^2\\). If \\(m \lt n\\) then `output` is computed as
+\\(X = A^H (A A^H + \lambda I)^{-1} B\\), which (for \\(\lambda = 0\\)) is the
+minimum-norm solution to the under-determined linear system, i.e.
+\\(X = \mathrm{argmin}_{Z \in \mathbb{C}^{n \times k} } ||Z||_F^2 \\),
+subject to \\(A Z = B\\). Notice that the fast path is only numerically stable
+when \\(A\\) is numerically full rank and has a condition number
+\\(\mathrm{cond}(A) \lt \frac{1}{\sqrt{\epsilon_{mach} } }\\) or\\(\lambda\\) is
+sufficiently large.
+
+If `fast` is `False` an algorithm based on the numerically robust complete
+orthogonal decomposition is used. This computes the minimum-norm
+least-squares solution, even when \\(A\\) is rank deficient. This path is
+typically 6-7 times slower than the fast path. If `fast` is `False` then
+`l2_regularizer` is ignored.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MatrixTriangularSolve.pbtxt b/tensorflow/core/api_def/base_api/api_def_MatrixTriangularSolve.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a2bfcdc66e48183edf054a3acbcaa462c80901fe
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MatrixTriangularSolve.pbtxt
@@ -0,0 +1,57 @@
+op {
+  graph_op_name: "MatrixTriangularSolve"
+  in_arg {
+    name: "matrix"
+    description: <<END
+Shape is `[..., M, M]`.
+END
+  }
+  in_arg {
+    name: "rhs"
+    description: <<END
+Shape is `[..., M, K]`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Shape is `[..., M, K]`.
+END
+  }
+  attr {
+    name: "lower"
+    description: <<END
+Boolean indicating whether the innermost matrices in `matrix` are
+lower or upper triangular.
+END
+  }
+  attr {
+    name: "adjoint"
+    description: <<END
+Boolean indicating whether to solve with `matrix` or its (block-wise)
+         adjoint.
+
+@compatibility(numpy)
+Equivalent to np.linalg.triangular_solve
+@end_compatibility
+END
+  }
+  summary: "Solves systems of linear equations with upper or lower triangular matrices by"
+  description: <<END
+backsubstitution.
+
+`matrix` is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions form
+square matrices. If `lower` is `True` then the strictly upper triangular part
+of each inner-most matrix is assumed to be zero and not accessed.
+If `lower` is False then the strictly lower triangular part of each inner-most
+matrix is assumed to be zero and not accessed.
+`rhs` is a tensor of shape `[..., M, K]`.
+
+The output is a tensor of shape `[..., M, K]`. If `adjoint` is
+`True` then the innermost matrices in `output` satisfy matrix equations
+`matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]`.
+If `adjoint` is `False` then the strictly then the  innermost matrices in
+`output` satisfy matrix equations
+`adjoint(matrix[..., i, k]) * output[..., k, j] = rhs[..., i, j]`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Max.pbtxt b/tensorflow/core/api_def/base_api/api_def_Max.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9a807d9f3755bba32c5c65b06d562ae1e152568e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Max.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "Max"
+  endpoint {
+    name: "Max"
+  }
+  endpoint {
+    name: "ReduceMax"
+  }
+  in_arg {
+    name: "input"
+    description: <<END
+The tensor to reduce.
+END
+  }
+  in_arg {
+    name: "reduction_indices"
+    rename_to: "axis"
+    description: <<END
+The dimensions to reduce. Must be in the range
+`[-rank(input), rank(input))`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The reduced tensor.
+END
+  }
+  attr {
+    name: "keep_dims"
+    description: <<END
+If true, retain reduced dimensions with length 1.
+END
+  }
+  summary: "Computes the maximum of elements across dimensions of a tensor."
+  description: <<END
+Reduces `input` along the dimensions given in `reduction_indices`. Unless
+`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+`reduction_indices`. If `keep_dims` is true, the reduced dimensions are
+retained with length 1.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MaxPool.pbtxt b/tensorflow/core/api_def/base_api/api_def_MaxPool.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..885bc1c2792bb5c825eb7ac6f029eb822f92fee7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MaxPool.pbtxt
@@ -0,0 +1,45 @@
+op {
+  graph_op_name: "MaxPool"
+  in_arg {
+    name: "input"
+    description: <<END
+4-D input to pool over.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The max pooled output tensor.
+END
+  }
+  attr {
+    name: "ksize"
+    description: <<END
+The size of the window for each dimension of the input tensor.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the
+input tensor.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+Specify the data format of the input and output data. With the
+default format "NHWC", the data is stored in the order of:
+    [batch, in_height, in_width, in_channels].
+Alternatively, the format could be "NCHW", the data storage order of:
+    [batch, in_channels, in_height, in_width].
+END
+  }
+  summary: "Performs max pooling on the input."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MaxPool3D.pbtxt b/tensorflow/core/api_def/base_api/api_def_MaxPool3D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8f07ee5fc1bdad548142b8a771d52e15be7dc0bc
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MaxPool3D.pbtxt
@@ -0,0 +1,46 @@
+op {
+  graph_op_name: "MaxPool3D"
+  in_arg {
+    name: "input"
+    description: <<END
+Shape `[batch, depth, rows, cols, channels]` tensor to pool over.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The max pooled output tensor.
+END
+  }
+  attr {
+    name: "ksize"
+    description: <<END
+1-D tensor of length 5. The size of the window for each dimension of
+the input tensor. Must have `ksize[0] = ksize[4] = 1`.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+1-D tensor of length 5. The stride of the sliding window for each
+dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+The data format of the input and output data. With the
+default format "NDHWC", the data is stored in the order of:
+    [batch, in_depth, in_height, in_width, in_channels].
+Alternatively, the format could be "NCDHW", the data storage order is:
+    [batch, in_channels, in_depth, in_height, in_width].
+END
+  }
+  summary: "Performs 3D max pooling on the input."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MaxPool3DGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_MaxPool3DGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..78c3c5f4bdb565c10eb8dbc794086300f4cb083d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MaxPool3DGrad.pbtxt
@@ -0,0 +1,52 @@
+op {
+  graph_op_name: "MaxPool3DGrad"
+  in_arg {
+    name: "orig_input"
+    description: <<END
+The original input tensor.
+END
+  }
+  in_arg {
+    name: "orig_output"
+    description: <<END
+The original output tensor.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+Output backprop of shape `[batch, depth, rows, cols, channels]`.
+END
+  }
+  attr {
+    name: "ksize"
+    description: <<END
+1-D tensor of length 5. The size of the window for each dimension of
+the input tensor. Must have `ksize[0] = ksize[4] = 1`.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+1-D tensor of length 5. The stride of the sliding window for each
+dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+The data format of the input and output data. With the
+default format "NDHWC", the data is stored in the order of:
+    [batch, in_depth, in_height, in_width, in_channels].
+Alternatively, the format could be "NCDHW", the data storage order is:
+    [batch, in_channels, in_depth, in_height, in_width].
+END
+  }
+  summary: "Computes gradients of max pooling function."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MaxPool3DGradGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_MaxPool3DGradGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7593e9a7fe815be74f8a3ff0877446991759e645
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MaxPool3DGradGrad.pbtxt
@@ -0,0 +1,58 @@
+op {
+  graph_op_name: "MaxPool3DGradGrad"
+  in_arg {
+    name: "orig_input"
+    description: <<END
+The original input tensor.
+END
+  }
+  in_arg {
+    name: "orig_output"
+    description: <<END
+The original output tensor.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+Output backprop of shape `[batch, depth, rows, cols, channels]`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Gradients of gradients w.r.t. the input to `max_pool`.
+END
+  }
+  attr {
+    name: "ksize"
+    description: <<END
+1-D tensor of length 5. The size of the window for each dimension of
+the input tensor. Must have `ksize[0] = ksize[4] = 1`.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+1-D tensor of length 5. The stride of the sliding window for each
+dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+The data format of the input and output data. With the
+default format "NDHWC", the data is stored in the order of:
+    [batch, in_depth, in_height, in_width, in_channels].
+Alternatively, the format could be "NCDHW", the data storage order is:
+    [batch, in_channels, in_depth, in_height, in_width].
+END
+  }
+  summary: "Computes second-order gradients of the maxpooling function."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MaxPoolGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_MaxPoolGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..be3e1972a03074211426f249070cdc86c1f3a467
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MaxPoolGrad.pbtxt
@@ -0,0 +1,58 @@
+op {
+  graph_op_name: "MaxPoolGrad"
+  visibility: HIDDEN
+  in_arg {
+    name: "orig_input"
+    description: <<END
+The original input tensor.
+END
+  }
+  in_arg {
+    name: "orig_output"
+    description: <<END
+The original output tensor.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+4-D.  Gradients w.r.t. the output of `max_pool`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Gradients w.r.t. the input to `max_pool`.
+END
+  }
+  attr {
+    name: "ksize"
+    description: <<END
+The size of the window for each dimension of the input tensor.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the
+input tensor.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+Specify the data format of the input and output data. With the
+default format "NHWC", the data is stored in the order of:
+    [batch, in_height, in_width, in_channels].
+Alternatively, the format could be "NCHW", the data storage order of:
+    [batch, in_channels, in_height, in_width].
+END
+  }
+  summary: "Computes gradients of the maxpooling function."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MaxPoolGradGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_MaxPoolGradGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..83f319001f16f7d00df75ceb0257424450393714
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MaxPoolGradGrad.pbtxt
@@ -0,0 +1,57 @@
+op {
+  graph_op_name: "MaxPoolGradGrad"
+  in_arg {
+    name: "orig_input"
+    description: <<END
+The original input tensor.
+END
+  }
+  in_arg {
+    name: "orig_output"
+    description: <<END
+The original output tensor.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+4-D.  Gradients of gradients w.r.t. the input of `max_pool`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Gradients of gradients w.r.t. the input to `max_pool`.
+END
+  }
+  attr {
+    name: "ksize"
+    description: <<END
+The size of the window for each dimension of the input tensor.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the
+input tensor.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+Specify the data format of the input and output data. With the
+default format "NHWC", the data is stored in the order of:
+    [batch, in_height, in_width, in_channels].
+Alternatively, the format could be "NCHW", the data storage order of:
+    [batch, in_channels, in_height, in_width].
+END
+  }
+  summary: "Computes second-order gradients of the maxpooling function."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MaxPoolGradGradV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_MaxPoolGradGradV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a55e02ac4022417b6f5d68a0e91762e5216ee49e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MaxPoolGradGradV2.pbtxt
@@ -0,0 +1,57 @@
+op {
+  graph_op_name: "MaxPoolGradGradV2"
+  in_arg {
+    name: "orig_input"
+    description: <<END
+The original input tensor.
+END
+  }
+  in_arg {
+    name: "orig_output"
+    description: <<END
+The original output tensor.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+4-D.  Gradients of gradients w.r.t. the input of `max_pool`.
+END
+  }
+  in_arg {
+    name: "ksize"
+    description: <<END
+The size of the window for each dimension of the input tensor.
+END
+  }
+  in_arg {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the
+input tensor.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Gradients of gradients w.r.t. the input to `max_pool`.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+Specify the data format of the input and output data. With the
+default format "NHWC", the data is stored in the order of:
+    [batch, in_height, in_width, in_channels].
+Alternatively, the format could be "NCHW", the data storage order of:
+    [batch, in_channels, in_height, in_width].
+END
+  }
+  summary: "Computes second-order gradients of the maxpooling function."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MaxPoolGradGradWithArgmax.pbtxt b/tensorflow/core/api_def/base_api/api_def_MaxPoolGradGradWithArgmax.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..63c5604d60e682efc378e91862e5c18f0082bc23
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MaxPoolGradGradWithArgmax.pbtxt
@@ -0,0 +1,48 @@
+op {
+  graph_op_name: "MaxPoolGradGradWithArgmax"
+  in_arg {
+    name: "input"
+    description: <<END
+The original input.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.  Gradients w.r.t. the
+input of `max_pool`.
+END
+  }
+  in_arg {
+    name: "argmax"
+    description: <<END
+The indices of the maximum values chosen for each output of `max_pool`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Gradients of gradients w.r.t. the input of `max_pool`.
+END
+  }
+  attr {
+    name: "ksize"
+    description: <<END
+The size of the window for each dimension of the input tensor.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the
+input tensor.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  summary: "Computes second-order gradients of the maxpooling function."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MaxPoolGradV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_MaxPoolGradV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e72877bb328007de3a9f49f5739bca1873fda06b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MaxPoolGradV2.pbtxt
@@ -0,0 +1,57 @@
+op {
+  graph_op_name: "MaxPoolGradV2"
+  in_arg {
+    name: "orig_input"
+    description: <<END
+The original input tensor.
+END
+  }
+  in_arg {
+    name: "orig_output"
+    description: <<END
+The original output tensor.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+4-D.  Gradients w.r.t. the output of `max_pool`.
+END
+  }
+  in_arg {
+    name: "ksize"
+    description: <<END
+The size of the window for each dimension of the input tensor.
+END
+  }
+  in_arg {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the
+input tensor.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Gradients w.r.t. the input to `max_pool`.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+Specify the data format of the input and output data. With the
+default format "NHWC", the data is stored in the order of:
+    [batch, in_height, in_width, in_channels].
+Alternatively, the format could be "NCHW", the data storage order of:
+    [batch, in_channels, in_height, in_width].
+END
+  }
+  summary: "Computes gradients of the maxpooling function."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MaxPoolGradWithArgmax.pbtxt b/tensorflow/core/api_def/base_api/api_def_MaxPoolGradWithArgmax.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4ae503e79d3abddbc972c66a662ed2e39bb4a024
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MaxPoolGradWithArgmax.pbtxt
@@ -0,0 +1,49 @@
+op {
+  graph_op_name: "MaxPoolGradWithArgmax"
+  visibility: HIDDEN
+  in_arg {
+    name: "input"
+    description: <<END
+The original input.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.  Gradients w.r.t. the
+output of `max_pool`.
+END
+  }
+  in_arg {
+    name: "argmax"
+    description: <<END
+The indices of the maximum values chosen for each output of `max_pool`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Gradients w.r.t. the input of `max_pool`.
+END
+  }
+  attr {
+    name: "ksize"
+    description: <<END
+The size of the window for each dimension of the input tensor.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the
+input tensor.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  summary: "Computes gradients of the maxpooling function."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MaxPoolV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_MaxPoolV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..51b1edff6fa659d54ba422c24a90775802c2af3c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MaxPoolV2.pbtxt
@@ -0,0 +1,45 @@
+op {
+  graph_op_name: "MaxPoolV2"
+  in_arg {
+    name: "input"
+    description: <<END
+4-D input to pool over.
+END
+  }
+  in_arg {
+    name: "ksize"
+    description: <<END
+The size of the window for each dimension of the input tensor.
+END
+  }
+  in_arg {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the
+input tensor.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The max pooled output tensor.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  attr {
+    name: "data_format"
+    description: <<END
+Specify the data format of the input and output data. With the
+default format "NHWC", the data is stored in the order of:
+    [batch, in_height, in_width, in_channels].
+Alternatively, the format could be "NCHW", the data storage order of:
+    [batch, in_channels, in_height, in_width].
+END
+  }
+  summary: "Performs max pooling on the input."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MaxPoolWithArgmax.pbtxt b/tensorflow/core/api_def/base_api/api_def_MaxPoolWithArgmax.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e717e57b50af3ee897c4ea7c309aebd72096f8a4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MaxPoolWithArgmax.pbtxt
@@ -0,0 +1,51 @@
+op {
+  graph_op_name: "MaxPoolWithArgmax"
+  in_arg {
+    name: "input"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.  Input to pool over.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The max pooled output tensor.
+END
+  }
+  out_arg {
+    name: "argmax"
+    description: <<END
+4-D.  The flattened indices of the max values chosen for each output.
+END
+  }
+  attr {
+    name: "ksize"
+    description: <<END
+The size of the window for each dimension of the input tensor.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the
+input tensor.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  summary: "Performs max pooling on the input and outputs both max values and indices."
+  description: <<END
+The indices in `argmax` are flattened, so that a maximum value at position
+`[b, y, x, c]` becomes flattened index
+`((b * height + y) * width + x) * channels + c`.
+
+The indices returned are always in `[0, height) x [0, width)` before flattening,
+even if padding is involved and the mathematically correct answer is outside
+(either negative or too large).  This is a bug, but fixing it is difficult to do
+in a safe backwards compatible way, especially due to flattening.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Maximum.pbtxt b/tensorflow/core/api_def/base_api/api_def_Maximum.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e52ca3f45d4d17db7d9353691938471f65bfa199
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Maximum.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "Maximum"
+  summary: "Returns the max of x and y (i.e. x > y ? x : y) element-wise."
+  description: <<END
+*NOTE*: `Maximum` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Mean.pbtxt b/tensorflow/core/api_def/base_api/api_def_Mean.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..71301621358fdce9d27a059fd6890608010a4f09
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Mean.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "Mean"
+  endpoint {
+    name: "Mean"
+  }
+  endpoint {
+    name: "ReduceMean"
+  }
+  in_arg {
+    name: "input"
+    description: <<END
+The tensor to reduce.
+END
+  }
+  in_arg {
+    name: "reduction_indices"
+    rename_to: "axis"
+    description: <<END
+The dimensions to reduce. Must be in the range
+`[-rank(input), rank(input))`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The reduced tensor.
+END
+  }
+  attr {
+    name: "keep_dims"
+    description: <<END
+If true, retain reduced dimensions with length 1.
+END
+  }
+  summary: "Computes the mean of elements across dimensions of a tensor."
+  description: <<END
+Reduces `input` along the dimensions given in `reduction_indices`. Unless
+`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+`reduction_indices`. If `keep_dims` is true, the reduced dimensions are
+retained with length 1.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Merge.pbtxt b/tensorflow/core/api_def/base_api/api_def_Merge.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..130c384158b96788aab47c39721cd608bcd6d1c5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Merge.pbtxt
@@ -0,0 +1,29 @@
+op {
+  graph_op_name: "Merge"
+  in_arg {
+    name: "inputs"
+    description: <<END
+The input tensors, exactly one of which will become available.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Will be set to the available input tensor.
+END
+  }
+  out_arg {
+    name: "value_index"
+    description: <<END
+The index of the chosen input tensor in `inputs`.
+END
+  }
+  summary: "Forwards the value of an available tensor from `inputs` to `output`."
+  description: <<END
+`Merge` waits for at least one of the tensors in `inputs` to become available.
+It is usually combined with `Switch` to implement branching.
+
+`Merge` forwards the first tensor to become available to `output`, and sets
+`value_index` to its index in `inputs`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MergeSummary.pbtxt b/tensorflow/core/api_def/base_api/api_def_MergeSummary.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..82596901848dc1678f9a30b203b19a1cc4b9f1fe
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MergeSummary.pbtxt
@@ -0,0 +1,26 @@
+op {
+  graph_op_name: "MergeSummary"
+  in_arg {
+    name: "inputs"
+    description: <<END
+Can be of any shape.  Each must contain serialized `Summary` protocol
+buffers.
+END
+  }
+  out_arg {
+    name: "summary"
+    description: <<END
+Scalar. Serialized `Summary` protocol buffer.
+END
+  }
+  summary: "Merges summaries."
+  description: <<END
+This op creates a
+[`Summary`](https://www.tensorflow.org/code/tensorflow/core/framework/summary.proto)
+protocol buffer that contains the union of all the values in the input
+summaries.
+
+When the Op is run, it reports an `InvalidArgument` error if multiple values
+in the summaries to merge use the same tag.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MergeV2Checkpoints.pbtxt b/tensorflow/core/api_def/base_api/api_def_MergeV2Checkpoints.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..88cc164eb17beec58eb3c55b7cbfe6d534439a9c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MergeV2Checkpoints.pbtxt
@@ -0,0 +1,33 @@
+op {
+  graph_op_name: "MergeV2Checkpoints"
+  in_arg {
+    name: "checkpoint_prefixes"
+    description: <<END
+prefixes of V2 checkpoints to merge.
+END
+  }
+  in_arg {
+    name: "destination_prefix"
+    description: <<END
+scalar.  The desired final prefix.  Allowed to be the same
+as one of the checkpoint_prefixes.
+END
+  }
+  attr {
+    name: "delete_old_dirs"
+    description: <<END
+see above.
+END
+  }
+  summary: "V2 format specific: merges the metadata files of sharded checkpoints.  The"
+  description: <<END
+result is one logical checkpoint, with one physical metadata file and renamed
+data files.
+
+Intended for "grouping" multiple checkpoints in a sharded checkpoint setup.
+
+If delete_old_dirs is true, attempts to delete recursively the dirname of each
+path in the input checkpoint_prefixes.  This is useful when those paths are non
+user-facing temporary locations.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Mfcc.pbtxt b/tensorflow/core/api_def/base_api/api_def_Mfcc.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..217a0367a522f337205159463db67d11759d426e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Mfcc.pbtxt
@@ -0,0 +1,51 @@
+op {
+  graph_op_name: "Mfcc"
+  in_arg {
+    name: "spectrogram"
+    description: <<END
+Typically produced by the Spectrogram op, with magnitude_squared
+set to true.
+END
+  }
+  in_arg {
+    name: "sample_rate"
+    description: <<END
+How many samples per second the source audio used.
+END
+  }
+  attr {
+    name: "upper_frequency_limit"
+    description: <<END
+The highest frequency to use when calculating the
+ceptstrum.
+END
+  }
+  attr {
+    name: "lower_frequency_limit"
+    description: <<END
+The lowest frequency to use when calculating the
+ceptstrum.
+END
+  }
+  attr {
+    name: "filterbank_channel_count"
+    description: <<END
+Resolution of the Mel bank used internally.
+END
+  }
+  attr {
+    name: "dct_coefficient_count"
+    description: <<END
+How many output channels to produce per time slice.
+END
+  }
+  summary: "Transforms a spectrogram into a form that\'s useful for speech recognition."
+  description: <<END
+Mel Frequency Cepstral Coefficients are a way of representing audio data that's
+been effective as an input feature for machine learning. They are created by
+taking the spectrum of a spectrogram (a 'cepstrum'), and discarding some of the
+higher frequencies that are less significant to the human ear. They have a long
+history in the speech recognition world, and https://en.wikipedia.org/wiki/Mel-frequency_cepstrum
+is a good resource to learn more.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Min.pbtxt b/tensorflow/core/api_def/base_api/api_def_Min.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0ddc865ab5233dec68101d8e693c00dfa2a2c7f8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Min.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "Min"
+  endpoint {
+    name: "Min"
+  }
+  endpoint {
+    name: "ReduceMin"
+  }
+  in_arg {
+    name: "input"
+    description: <<END
+The tensor to reduce.
+END
+  }
+  in_arg {
+    name: "reduction_indices"
+    rename_to: "axis"
+    description: <<END
+The dimensions to reduce. Must be in the range
+`[-rank(input), rank(input))`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The reduced tensor.
+END
+  }
+  attr {
+    name: "keep_dims"
+    description: <<END
+If true, retain reduced dimensions with length 1.
+END
+  }
+  summary: "Computes the minimum of elements across dimensions of a tensor."
+  description: <<END
+Reduces `input` along the dimensions given in `reduction_indices`. Unless
+`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+`reduction_indices`. If `keep_dims` is true, the reduced dimensions are
+retained with length 1.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Minimum.pbtxt b/tensorflow/core/api_def/base_api/api_def_Minimum.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d0997f1a5c10226ddd838d92d000845a88453235
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Minimum.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "Minimum"
+  summary: "Returns the min of x and y (i.e. x < y ? x : y) element-wise."
+  description: <<END
+*NOTE*: `Minimum` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MirrorPad.pbtxt b/tensorflow/core/api_def/base_api/api_def_MirrorPad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6f738f72ce94f6586a7e6b6d57b096883807c8c7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MirrorPad.pbtxt
@@ -0,0 +1,60 @@
+op {
+  graph_op_name: "MirrorPad"
+  in_arg {
+    name: "input"
+    description: <<END
+The input tensor to be padded.
+END
+  }
+  in_arg {
+    name: "paddings"
+    description: <<END
+A two-column matrix specifying the padding sizes. The number of
+rows must be the same as the rank of `input`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The padded tensor.
+END
+  }
+  attr {
+    name: "mode"
+    description: <<END
+Either `REFLECT` or `SYMMETRIC`. In reflect mode the padded regions
+do not include the borders, while in symmetric mode the padded regions
+do include the borders. For example, if `input` is `[1, 2, 3]` and `paddings`
+is `[0, 2]`, then the output is `[1, 2, 3, 2, 1]` in reflect mode, and
+it is `[1, 2, 3, 3, 2]` in symmetric mode.
+END
+  }
+  summary: "Pads a tensor with mirrored values."
+  description: <<END
+This operation pads a `input` with mirrored values according to the `paddings`
+you specify. `paddings` is an integer tensor with shape `[n, 2]`, where n is
+the rank of `input`. For each dimension D of `input`, `paddings[D, 0]` indicates
+how many values to add before the contents of `input` in that dimension, and
+`paddings[D, 1]` indicates how many values to add after the contents of `input`
+in that dimension. Both `paddings[D, 0]` and `paddings[D, 1]` must be no greater
+than `input.dim_size(D)` (or `input.dim_size(D) - 1`) if `copy_border` is true
+(if false, respectively).
+
+The padded size of each dimension D of the output is:
+
+`paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
+
+For example:
+
+```
+# 't' is [[1, 2, 3], [4, 5, 6]].
+# 'paddings' is [[1, 1]], [2, 2]].
+# 'mode' is SYMMETRIC.
+# rank of 't' is 2.
+pad(t, paddings) ==> [[2, 1, 1, 2, 3, 3, 2]
+                      [2, 1, 1, 2, 3, 3, 2]
+                      [5, 4, 4, 5, 6, 6, 5]
+                      [5, 4, 4, 5, 6, 6, 5]]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MirrorPadGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_MirrorPadGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..20db99a9d1af034c6d0cec8fcfd0bdcc1c65939d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MirrorPadGrad.pbtxt
@@ -0,0 +1,50 @@
+op {
+  graph_op_name: "MirrorPadGrad"
+  visibility: HIDDEN
+  in_arg {
+    name: "input"
+    description: <<END
+The input tensor to be folded.
+END
+  }
+  in_arg {
+    name: "paddings"
+    description: <<END
+A two-column matrix specifying the padding sizes. The number of
+rows must be the same as the rank of `input`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The folded tensor.
+END
+  }
+  attr {
+    name: "mode"
+    description: <<END
+The mode used in the `MirrorPad` op.
+END
+  }
+  summary: "Gradient op for `MirrorPad` op. This op folds a mirror-padded tensor."
+  description: <<END
+This operation folds the padded areas of `input` by `MirrorPad` according to the
+`paddings` you specify. `paddings` must be the same as `paddings` argument
+given to the corresponding `MirrorPad` op.
+
+The folded size of each dimension D of the output is:
+
+`input.dim_size(D) - paddings(D, 0) - paddings(D, 1)`
+
+For example:
+
+```
+# 't' is [[1, 2, 3], [4, 5, 6], [7, 8, 9]].
+# 'paddings' is [[0, 1]], [0, 1]].
+# 'mode' is SYMMETRIC.
+# rank of 't' is 2.
+pad(t, paddings) ==> [[ 1,  5]
+                      [11, 28]]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Mod.pbtxt b/tensorflow/core/api_def/base_api/api_def_Mod.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2a49ccff687024450d681442880455b74fce30a2
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Mod.pbtxt
@@ -0,0 +1,11 @@
+op {
+  graph_op_name: "Mod"
+  summary: "Returns element-wise remainder of division. This emulates C semantics in that"
+  description: <<END
+the result here is consistent with a truncating divide. E.g.
+`tf.truncatediv(x, y) * y + truncate_mod(x, y) = x`.
+
+*NOTE*: `Mod` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Mul.pbtxt b/tensorflow/core/api_def/base_api/api_def_Mul.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..13fad871f38d6159da9ff0978a1e49bc78ffe71f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Mul.pbtxt
@@ -0,0 +1,14 @@
+op {
+  graph_op_name: "Mul"
+  endpoint {
+    name: "Multiply"
+  }
+  endpoint {
+    name: "Mul"
+  }
+  summary: "Returns x * y element-wise."
+  description: <<END
+*NOTE*: `Mul` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Multinomial.pbtxt b/tensorflow/core/api_def/base_api/api_def_Multinomial.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..974e81e0fda5fd3b77d025a8960e9a61e6e58bcd
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Multinomial.pbtxt
@@ -0,0 +1,37 @@
+op {
+  graph_op_name: "Multinomial"
+  in_arg {
+    name: "logits"
+    description: <<END
+2-D Tensor with shape `[batch_size, num_classes]`.  Each slice `[i, :]`
+represents the unnormalized log probabilities for all classes.
+END
+  }
+  in_arg {
+    name: "num_samples"
+    description: <<END
+0-D.  Number of independent samples to draw for each row slice.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+2-D Tensor with shape `[batch_size, num_samples]`.  Each slice `[i, :]`
+contains the drawn class labels with range `[0, num_classes)`.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either seed or seed2 is set to be non-zero, the internal random number
+generator is seeded by the given seed.  Otherwise, a random seed is used.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+A second seed to avoid seed collision.
+END
+  }
+  summary: "Draws samples from a multinomial distribution."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MutableDenseHashTable.pbtxt b/tensorflow/core/api_def/base_api/api_def_MutableDenseHashTable.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..eaaed081cc8f92889bb8f76b3a190ebc3613968b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MutableDenseHashTable.pbtxt
@@ -0,0 +1,72 @@
+op {
+  graph_op_name: "MutableDenseHashTable"
+  visibility: SKIP
+  in_arg {
+    name: "empty_key"
+    description: <<END
+The key used to represent empty key buckets internally. Must not
+be used in insert or lookup operations.
+END
+  }
+  out_arg {
+    name: "table_handle"
+    description: <<END
+Handle to a table.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this table is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this table is shared under the given name across
+multiple sessions.
+END
+  }
+  attr {
+    name: "key_dtype"
+    description: <<END
+Type of the table keys.
+END
+  }
+  attr {
+    name: "value_dtype"
+    description: <<END
+Type of the table values.
+END
+  }
+  attr {
+    name: "value_shape"
+    description: <<END
+The shape of each value.
+END
+  }
+  attr {
+    name: "initial_num_buckets"
+    description: <<END
+The initial number of hash table buckets. Must be a power
+to 2.
+END
+  }
+  attr {
+    name: "max_load_factor"
+    description: <<END
+The maximum ratio between number of entries and number of
+buckets before growing the table. Must be between 0 and 1.
+END
+  }
+  summary: "Creates an empty hash table that uses tensors as the backing store."
+  description: <<END
+It uses "open addressing" with quadratic reprobing to resolve
+collisions.
+
+This op creates a mutable hash table, specifying the type of its keys and
+values. Each value must be a scalar. Data can be inserted into the table using
+the insert operations. It does not support the initialization operation.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MutableDenseHashTableV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_MutableDenseHashTableV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..55fce8317536ccde027a1fbad059837ccd462ffa
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MutableDenseHashTableV2.pbtxt
@@ -0,0 +1,74 @@
+op {
+  graph_op_name: "MutableDenseHashTableV2"
+  endpoint {
+    name: "MutableDenseHashTable"
+  }
+  in_arg {
+    name: "empty_key"
+    description: <<END
+The key used to represent empty key buckets internally. Must not
+be used in insert or lookup operations.
+END
+  }
+  out_arg {
+    name: "table_handle"
+    description: <<END
+Handle to a table.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this table is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this table is shared under the given name across
+multiple sessions.
+END
+  }
+  attr {
+    name: "key_dtype"
+    description: <<END
+Type of the table keys.
+END
+  }
+  attr {
+    name: "value_dtype"
+    description: <<END
+Type of the table values.
+END
+  }
+  attr {
+    name: "value_shape"
+    description: <<END
+The shape of each value.
+END
+  }
+  attr {
+    name: "initial_num_buckets"
+    description: <<END
+The initial number of hash table buckets. Must be a power
+to 2.
+END
+  }
+  attr {
+    name: "max_load_factor"
+    description: <<END
+The maximum ratio between number of entries and number of
+buckets before growing the table. Must be between 0 and 1.
+END
+  }
+  summary: "Creates an empty hash table that uses tensors as the backing store."
+  description: <<END
+It uses "open addressing" with quadratic reprobing to resolve
+collisions.
+
+This op creates a mutable hash table, specifying the type of its keys and
+values. Each value must be a scalar. Data can be inserted into the table using
+the insert operations. It does not support the initialization operation.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MutableHashTable.pbtxt b/tensorflow/core/api_def/base_api/api_def_MutableHashTable.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4bcdcdaf8ae916bdb1662308c36d5fa4b2a7d2b3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MutableHashTable.pbtxt
@@ -0,0 +1,49 @@
+op {
+  graph_op_name: "MutableHashTable"
+  visibility: SKIP
+  out_arg {
+    name: "table_handle"
+    description: <<END
+Handle to a table.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this table is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this table is shared under the given name across
+multiple sessions.
+END
+  }
+  attr {
+    name: "use_node_name_sharing"
+    description: <<END
+If true and shared_name is empty, the table is shared
+using the node name.
+END
+  }
+  attr {
+    name: "key_dtype"
+    description: <<END
+Type of the table keys.
+END
+  }
+  attr {
+    name: "value_dtype"
+    description: <<END
+Type of the table values.
+END
+  }
+  summary: "Creates an empty hash table."
+  description: <<END
+This op creates a mutable hash table, specifying the type of its keys and
+values. Each value must be a scalar. Data can be inserted into the table using
+the insert operations. It does not support the initialization operation.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MutableHashTableOfTensors.pbtxt b/tensorflow/core/api_def/base_api/api_def_MutableHashTableOfTensors.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9bb37a3c4045446c13aae5b2cf229e20259aee15
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MutableHashTableOfTensors.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "MutableHashTableOfTensors"
+  visibility: SKIP
+  out_arg {
+    name: "table_handle"
+    description: <<END
+Handle to a table.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this table is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this table is shared under the given name across
+multiple sessions.
+END
+  }
+  attr {
+    name: "key_dtype"
+    description: <<END
+Type of the table keys.
+END
+  }
+  attr {
+    name: "value_dtype"
+    description: <<END
+Type of the table values.
+END
+  }
+  summary: "Creates an empty hash table."
+  description: <<END
+This op creates a mutable hash table, specifying the type of its keys and
+values. Each value must be a vector. Data can be inserted into the table using
+the insert operations. It does not support the initialization operation.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MutableHashTableOfTensorsV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_MutableHashTableOfTensorsV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1007cc96c0bb54db6301242cdd06b97e5523c22b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MutableHashTableOfTensorsV2.pbtxt
@@ -0,0 +1,44 @@
+op {
+  graph_op_name: "MutableHashTableOfTensorsV2"
+  endpoint {
+    name: "MutableHashTableOfTensors"
+  }
+  out_arg {
+    name: "table_handle"
+    description: <<END
+Handle to a table.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this table is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this table is shared under the given name across
+multiple sessions.
+END
+  }
+  attr {
+    name: "key_dtype"
+    description: <<END
+Type of the table keys.
+END
+  }
+  attr {
+    name: "value_dtype"
+    description: <<END
+Type of the table values.
+END
+  }
+  summary: "Creates an empty hash table."
+  description: <<END
+This op creates a mutable hash table, specifying the type of its keys and
+values. Each value must be a vector. Data can be inserted into the table using
+the insert operations. It does not support the initialization operation.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_MutableHashTableV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_MutableHashTableV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0b37b5b07f8c24bac26a8ce770f752070d3fe2e7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_MutableHashTableV2.pbtxt
@@ -0,0 +1,51 @@
+op {
+  graph_op_name: "MutableHashTableV2"
+  endpoint {
+    name: "MutableHashTable"
+  }
+  out_arg {
+    name: "table_handle"
+    description: <<END
+Handle to a table.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this table is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this table is shared under the given name across
+multiple sessions.
+END
+  }
+  attr {
+    name: "use_node_name_sharing"
+    description: <<END
+If true and shared_name is empty, the table is shared
+using the node name.
+END
+  }
+  attr {
+    name: "key_dtype"
+    description: <<END
+Type of the table keys.
+END
+  }
+  attr {
+    name: "value_dtype"
+    description: <<END
+Type of the table values.
+END
+  }
+  summary: "Creates an empty hash table."
+  description: <<END
+This op creates a mutable hash table, specifying the type of its keys and
+values. Each value must be a scalar. Data can be inserted into the table using
+the insert operations. It does not support the initialization operation.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_N.pbtxt b/tensorflow/core/api_def/base_api/api_def_N.pbtxt
deleted file mode 100644
index 0298a42cab9109bb96af4e8bdea25c6211574523..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_N.pbtxt
+++ /dev/null
@@ -1,94 +0,0 @@
-op {
-  graph_op_name: "Neg"
-  endpoint {
-    name: "Neg"
-  }
-  summary: "Computes numerical negative value element-wise."
-  description: <<END
-I.e., \\(y = -x\\).
-END
-}
-op {
-  graph_op_name: "NegTrain"
-  endpoint {
-    name: "NegTrain"
-  }
-  summary: "Training via negative sampling."
-}
-op {
-  graph_op_name: "NextIteration"
-  endpoint {
-    name: "NextIteration"
-  }
-  summary: "Makes its input available to the next iteration."
-}
-op {
-  graph_op_name: "NoOp"
-  endpoint {
-    name: "NoOp"
-  }
-  summary: "Does nothing. Only useful as a placeholder for control edges."
-}
-op {
-  graph_op_name: "NonMaxSuppression"
-  endpoint {
-    name: "NonMaxSuppression"
-  }
-  summary: "Greedily selects a subset of bounding boxes in descending order of score,"
-  description: <<END
-pruning away boxes that have high intersection-over-union (IOU) overlap
-with previously selected boxes.  Bounding boxes are supplied as
-[y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
-diagonal pair of box corners and the coordinates can be provided as normalized
-(i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
-is agnostic to where the origin is in the coordinate system.  Note that this
-algorithm is invariant to orthogonal transformations and translations
-of the coordinate system; thus translating or reflections of the coordinate
-system result in the same boxes being selected by the algorithm.
-The output of this operation is a set of integers indexing into the input
-collection of bounding boxes representing the selected boxes.  The bounding
-box coordinates corresponding to the selected indices can then be obtained
-using the `tf.gather operation`.  For example:
-  selected_indices = tf.image.non_max_suppression(
-      boxes, scores, max_output_size, iou_threshold)
-  selected_boxes = tf.gather(boxes, selected_indices)
-END
-}
-op {
-  graph_op_name: "NonMaxSuppressionV2"
-  endpoint {
-    name: "NonMaxSuppressionV2"
-  }
-  summary: "Greedily selects a subset of bounding boxes in descending order of score,"
-  description: <<END
-pruning away boxes that have high intersection-over-union (IOU) overlap
-with previously selected boxes.  Bounding boxes are supplied as
-[y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
-diagonal pair of box corners and the coordinates can be provided as normalized
-(i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
-is agnostic to where the origin is in the coordinate system.  Note that this
-algorithm is invariant to orthogonal transformations and translations
-of the coordinate system; thus translating or reflections of the coordinate
-system result in the same boxes being selected by the algorithm.
-
-The output of this operation is a set of integers indexing into the input
-collection of bounding boxes representing the selected boxes.  The bounding
-box coordinates corresponding to the selected indices can then be obtained
-using the `tf.gather operation`.  For example:
-
-  selected_indices = tf.image.non_max_suppression_v2(
-      boxes, scores, max_output_size, iou_threshold)
-  selected_boxes = tf.gather(boxes, selected_indices)
-END
-}
-op {
-  graph_op_name: "NotEqual"
-  endpoint {
-    name: "NotEqual"
-  }
-  summary: "Returns the truth value of (x != y) element-wise."
-  description: <<END
-*NOTE*: `NotEqual` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_Neg.pbtxt b/tensorflow/core/api_def/base_api/api_def_Neg.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..dafa218e5a92a321b1df8e1f77ea7b160e90b7fa
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Neg.pbtxt
@@ -0,0 +1,13 @@
+op {
+  graph_op_name: "Neg"
+  endpoint {
+    name: "Negate"
+  }
+  endpoint {
+    name: "Neg"
+  }
+  summary: "Computes numerical negative value element-wise."
+  description: <<END
+I.e., \\(y = -x\\).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_NegTrain.pbtxt b/tensorflow/core/api_def/base_api/api_def_NegTrain.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4c8efac053b7e23db7eaee64432c0f4a6b2cfb10
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_NegTrain.pbtxt
@@ -0,0 +1,40 @@
+op {
+  graph_op_name: "NegTrain"
+  in_arg {
+    name: "w_in"
+    description: <<END
+input word embedding.
+END
+  }
+  in_arg {
+    name: "w_out"
+    description: <<END
+output word embedding.
+END
+  }
+  in_arg {
+    name: "examples"
+    description: <<END
+A vector of word ids.
+END
+  }
+  in_arg {
+    name: "labels"
+    description: <<END
+A vector of word ids.
+END
+  }
+  attr {
+    name: "vocab_count"
+    description: <<END
+Count of words in the vocabulary.
+END
+  }
+  attr {
+    name: "num_negative_samples"
+    description: <<END
+Number of negative samples per example.
+END
+  }
+  summary: "Training via negative sampling."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_NextIteration.pbtxt b/tensorflow/core/api_def/base_api/api_def_NextIteration.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..13178619efe2411adc184b861cfe258643dcdf56
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_NextIteration.pbtxt
@@ -0,0 +1,16 @@
+op {
+  graph_op_name: "NextIteration"
+  in_arg {
+    name: "data"
+    description: <<END
+The tensor to be made available to the next iteration.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The same tensor as `data`.
+END
+  }
+  summary: "Makes its input available to the next iteration."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_NoOp.pbtxt b/tensorflow/core/api_def/base_api/api_def_NoOp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d860149adc3b6975e8dbf3301210ffbc68d1a34e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_NoOp.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "NoOp"
+  summary: "Does nothing. Only useful as a placeholder for control edges."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_NonMaxSuppression.pbtxt b/tensorflow/core/api_def/base_api/api_def_NonMaxSuppression.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c8352b1b8c3b33c2e1875fe08ffdc6d4c03513c8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_NonMaxSuppression.pbtxt
@@ -0,0 +1,56 @@
+op {
+  graph_op_name: "NonMaxSuppression"
+  in_arg {
+    name: "boxes"
+    description: <<END
+A 2-D float tensor of shape `[num_boxes, 4]`.
+END
+  }
+  in_arg {
+    name: "scores"
+    description: <<END
+A 1-D float tensor of shape `[num_boxes]` representing a single
+score corresponding to each box (each row of boxes).
+END
+  }
+  in_arg {
+    name: "max_output_size"
+    description: <<END
+A scalar integer tensor representing the maximum number of
+boxes to be selected by non max suppression.
+END
+  }
+  out_arg {
+    name: "selected_indices"
+    description: <<END
+A 1-D integer tensor of shape `[M]` representing the selected
+indices from the boxes tensor, where `M <= max_output_size`.
+END
+  }
+  attr {
+    name: "iou_threshold"
+    description: <<END
+A float representing the threshold for deciding whether boxes
+overlap too much with respect to IOU.
+END
+  }
+  summary: "Greedily selects a subset of bounding boxes in descending order of score,"
+  description: <<END
+pruning away boxes that have high intersection-over-union (IOU) overlap
+with previously selected boxes.  Bounding boxes are supplied as
+[y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
+diagonal pair of box corners and the coordinates can be provided as normalized
+(i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
+is agnostic to where the origin is in the coordinate system.  Note that this
+algorithm is invariant to orthogonal transformations and translations
+of the coordinate system; thus translating or reflections of the coordinate
+system result in the same boxes being selected by the algorithm.
+The output of this operation is a set of integers indexing into the input
+collection of bounding boxes representing the selected boxes.  The bounding
+box coordinates corresponding to the selected indices can then be obtained
+using the `tf.gather operation`.  For example:
+  selected_indices = tf.image.non_max_suppression(
+      boxes, scores, max_output_size, iou_threshold)
+  selected_boxes = tf.gather(boxes, selected_indices)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_NonMaxSuppressionV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_NonMaxSuppressionV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..42146d106c38708eb7fe72463b5dadeb1951ee80
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_NonMaxSuppressionV2.pbtxt
@@ -0,0 +1,58 @@
+op {
+  graph_op_name: "NonMaxSuppressionV2"
+  in_arg {
+    name: "boxes"
+    description: <<END
+A 2-D float tensor of shape `[num_boxes, 4]`.
+END
+  }
+  in_arg {
+    name: "scores"
+    description: <<END
+A 1-D float tensor of shape `[num_boxes]` representing a single
+score corresponding to each box (each row of boxes).
+END
+  }
+  in_arg {
+    name: "max_output_size"
+    description: <<END
+A scalar integer tensor representing the maximum number of
+boxes to be selected by non max suppression.
+END
+  }
+  in_arg {
+    name: "iou_threshold"
+    description: <<END
+A 0-D float tensor representing the threshold for deciding whether
+boxes overlap too much with respect to IOU.
+END
+  }
+  out_arg {
+    name: "selected_indices"
+    description: <<END
+A 1-D integer tensor of shape `[M]` representing the selected
+indices from the boxes tensor, where `M <= max_output_size`.
+END
+  }
+  summary: "Greedily selects a subset of bounding boxes in descending order of score,"
+  description: <<END
+pruning away boxes that have high intersection-over-union (IOU) overlap
+with previously selected boxes.  Bounding boxes are supplied as
+[y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
+diagonal pair of box corners and the coordinates can be provided as normalized
+(i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
+is agnostic to where the origin is in the coordinate system.  Note that this
+algorithm is invariant to orthogonal transformations and translations
+of the coordinate system; thus translating or reflections of the coordinate
+system result in the same boxes being selected by the algorithm.
+
+The output of this operation is a set of integers indexing into the input
+collection of bounding boxes representing the selected boxes.  The bounding
+box coordinates corresponding to the selected indices can then be obtained
+using the `tf.gather operation`.  For example:
+
+  selected_indices = tf.image.non_max_suppression_v2(
+      boxes, scores, max_output_size, iou_threshold)
+  selected_boxes = tf.gather(boxes, selected_indices)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_NotEqual.pbtxt b/tensorflow/core/api_def/base_api/api_def_NotEqual.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5c4b31853491a71d68b6f6a91fe1327728cd885d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_NotEqual.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "NotEqual"
+  summary: "Returns the truth value of (x != y) element-wise."
+  description: <<END
+*NOTE*: `NotEqual` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_NthElement.pbtxt b/tensorflow/core/api_def/base_api/api_def_NthElement.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9ef20a26db80ce3199041142938e953ac827d750
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_NthElement.pbtxt
@@ -0,0 +1,39 @@
+op {
+  graph_op_name: "NthElement"
+  in_arg {
+    name: "input"
+    description: <<END
+1-D or higher with last dimension at least `n+1`.
+END
+  }
+  in_arg {
+    name: "n"
+    description: <<END
+0-D. Position of sorted vector to select along the last dimension (along
+each row for matrices). Valid range of n is `[0, input.shape[:-1])`
+END
+  }
+  out_arg {
+    name: "values"
+    description: <<END
+The `n`-th order statistic along each last dimensional slice.
+END
+  }
+  attr {
+    name: "reverse"
+    description: <<END
+When set to True, find the nth-largest value in the vector and vice
+versa.
+END
+  }
+  summary: "Finds values of the `n`-th order statistic for the last dmension."
+  description: <<END
+If the input is a vector (rank-1), finds the entries which is the nth-smallest
+value in the vector and outputs their values as scalar tensor.
+
+For matrices (resp. higher rank input), computes the entries which is the
+nth-smallest value in each row (resp. vector along the last dimension). Thus,
+
+    values.shape = input.shape[:-1]
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_O.pbtxt b/tensorflow/core/api_def/base_api/api_def_O.pbtxt
deleted file mode 100644
index 3c62335da9a508b36b857c15990bc4c4a5db05fc..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_O.pbtxt
+++ /dev/null
@@ -1,195 +0,0 @@
-op {
-  graph_op_name: "OneHot"
-  endpoint {
-    name: "OneHot"
-  }
-  summary: "Returns a one-hot tensor."
-  description: <<END
-The locations represented by indices in `indices` take value `on_value`,
-while all other locations take value `off_value`.
-
-If the input `indices` is rank `N`, the output will have rank `N+1`,
-The new axis is created at dimension `axis` (default: the new axis is
-appended at the end).
-
-If `indices` is a scalar the output shape will be a vector of length `depth`.
-
-If `indices` is a vector of length `features`, the output shape will be:
-```
-  features x depth if axis == -1
-  depth x features if axis == 0
-```
-
-If `indices` is a matrix (batch) with shape `[batch, features]`,
-the output shape will be:
-```
-  batch x features x depth if axis == -1
-  batch x depth x features if axis == 1
-  depth x batch x features if axis == 0
-```
-
-
-Examples
-=========
-
-Suppose that
-
-```
-  indices = [0, 2, -1, 1]
-  depth = 3
-  on_value = 5.0
-  off_value = 0.0
-  axis = -1
-```
-
-Then output is `[4 x 3]`:
-
-    ```output =
-      [5.0 0.0 0.0]  // one_hot(0)
-      [0.0 0.0 5.0]  // one_hot(2)
-      [0.0 0.0 0.0]  // one_hot(-1)
-      [0.0 5.0 0.0]  // one_hot(1)
-    ```
-
-Suppose that
-
-```
-  indices = [0, 2, -1, 1]
-  depth = 3
-  on_value = 0.0
-  off_value = 3.0
-  axis = 0
-```
-
-Then output is `[3 x 4]`:
-
-    ```output =
-      [0.0 3.0 3.0 3.0]
-      [3.0 3.0 3.0 0.0]
-      [3.0 3.0 3.0 3.0]
-      [3.0 0.0 3.0 3.0]
-    //  ^                one_hot(0)
-    //      ^            one_hot(2)
-    //          ^        one_hot(-1)
-    //              ^    one_hot(1)
-    ```
-Suppose that
-
-```
-  indices = [[0, 2], [1, -1]]
-  depth = 3
-  on_value = 1.0
-  off_value = 0.0
-  axis = -1
-```
-
-Then output is `[2 x 2 x 3]`:
-
-    ```output =
-      [
-        [1.0, 0.0, 0.0]  // one_hot(0)
-        [0.0, 0.0, 1.0]  // one_hot(2)
-      ][
-        [0.0, 1.0, 0.0]  // one_hot(1)
-        [0.0, 0.0, 0.0]  // one_hot(-1)
-      ]```
-END
-}
-op {
-  graph_op_name: "OneShotIterator"
-  endpoint {
-    name: "OneShotIterator"
-  }
-  summary: "Makes a \"one-shot\" iterator that can be iterated only once."
-  description: <<END
-A one-shot iterator bundles the logic for defining the dataset and
-the state of the iterator in a single op, which allows simple input
-pipelines to be defined without an additional initialization
-("MakeIterator") step.
-
-One-shot iterators have the following limitations:
-
-* They do not support parameterization: all logic for creating the underlying
-  dataset must be bundled in the `dataset_factory` function.
-* They are not resettable. Once a one-shot iterator reaches the end of its
-  underlying dataset, subsequent "IteratorGetNext" operations on that
-  iterator will always produce an `OutOfRange` error.
-
-For greater flexibility, use "Iterator" and "MakeIterator" to define
-an iterator using an arbitrary subgraph, which may capture tensors
-(including fed values) as parameters, and which may be reset multiple
-times by rerunning "MakeIterator".
-END
-}
-op {
-  graph_op_name: "OnesLike"
-  endpoint {
-    name: "OnesLike"
-  }
-  summary: "Returns a tensor of ones with the same shape and type as x."
-}
-op {
-  graph_op_name: "OrderedMapClear"
-  endpoint {
-    name: "OrderedMapClear"
-  }
-  summary: "Op removes all elements in the underlying container."
-}
-op {
-  graph_op_name: "OrderedMapIncompleteSize"
-  endpoint {
-    name: "OrderedMapIncompleteSize"
-  }
-  summary: "Op returns the number of incomplete elements in the underlying container."
-}
-op {
-  graph_op_name: "OrderedMapPeek"
-  endpoint {
-    name: "OrderedMapPeek"
-  }
-  summary: "Op peeks at the values at the specified key.  If the"
-  description: <<END
-underlying container does not contain this key
-this op will block until it does.   This Op is optimized for
-performance.
-END
-}
-op {
-  graph_op_name: "OrderedMapSize"
-  endpoint {
-    name: "OrderedMapSize"
-  }
-  summary: "Op returns the number of elements in the underlying container."
-}
-op {
-  graph_op_name: "OrderedMapStage"
-  endpoint {
-    name: "OrderedMapStage"
-  }
-  summary: "Stage (key, values) in the underlying container which behaves like a ordered"
-  description: <<END
-associative container.   Elements are ordered by key.
-END
-}
-op {
-  graph_op_name: "OrderedMapUnstage"
-  endpoint {
-    name: "OrderedMapUnstage"
-  }
-  summary: "Op removes and returns the values associated with the key"
-  description: <<END
-from the underlying container.   If the underlying container
-does not contain this key, the op will block until it does.
-END
-}
-op {
-  graph_op_name: "OrderedMapUnstageNoKey"
-  endpoint {
-    name: "OrderedMapUnstageNoKey"
-  }
-  summary: "Op removes and returns the (key, value) element with the smallest"
-  description: <<END
-key from the underlying container.   If the underlying container
-does not contain elements, the op will block until it does.
-END
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_OneHot.pbtxt b/tensorflow/core/api_def/base_api/api_def_OneHot.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..807b8ae31015e4bcb73e54e98d879460f0d92f62
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_OneHot.pbtxt
@@ -0,0 +1,130 @@
+op {
+  graph_op_name: "OneHot"
+  in_arg {
+    name: "indices"
+    description: <<END
+A tensor of indices.
+END
+  }
+  in_arg {
+    name: "depth"
+    description: <<END
+A scalar defining the depth of the one hot dimension.
+END
+  }
+  in_arg {
+    name: "on_value"
+    description: <<END
+A scalar defining the value to fill in output when `indices[j] = i`.
+END
+  }
+  in_arg {
+    name: "off_value"
+    description: <<END
+A scalar defining the value to fill in output when `indices[j] != i`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The one-hot tensor.
+END
+  }
+  attr {
+    name: "axis"
+    description: <<END
+The axis to fill (default: -1, a new inner-most axis).
+END
+  }
+  summary: "Returns a one-hot tensor."
+  description: <<END
+The locations represented by indices in `indices` take value `on_value`,
+while all other locations take value `off_value`.
+
+If the input `indices` is rank `N`, the output will have rank `N+1`,
+The new axis is created at dimension `axis` (default: the new axis is
+appended at the end).
+
+If `indices` is a scalar the output shape will be a vector of length `depth`.
+
+If `indices` is a vector of length `features`, the output shape will be:
+```
+  features x depth if axis == -1
+  depth x features if axis == 0
+```
+
+If `indices` is a matrix (batch) with shape `[batch, features]`,
+the output shape will be:
+```
+  batch x features x depth if axis == -1
+  batch x depth x features if axis == 1
+  depth x batch x features if axis == 0
+```
+
+
+Examples
+=========
+
+Suppose that
+
+```
+  indices = [0, 2, -1, 1]
+  depth = 3
+  on_value = 5.0
+  off_value = 0.0
+  axis = -1
+```
+
+Then output is `[4 x 3]`:
+
+    ```output =
+      [5.0 0.0 0.0]  // one_hot(0)
+      [0.0 0.0 5.0]  // one_hot(2)
+      [0.0 0.0 0.0]  // one_hot(-1)
+      [0.0 5.0 0.0]  // one_hot(1)
+    ```
+
+Suppose that
+
+```
+  indices = [0, 2, -1, 1]
+  depth = 3
+  on_value = 0.0
+  off_value = 3.0
+  axis = 0
+```
+
+Then output is `[3 x 4]`:
+
+    ```output =
+      [0.0 3.0 3.0 3.0]
+      [3.0 3.0 3.0 0.0]
+      [3.0 3.0 3.0 3.0]
+      [3.0 0.0 3.0 3.0]
+    //  ^                one_hot(0)
+    //      ^            one_hot(2)
+    //          ^        one_hot(-1)
+    //              ^    one_hot(1)
+    ```
+Suppose that
+
+```
+  indices = [[0, 2], [1, -1]]
+  depth = 3
+  on_value = 1.0
+  off_value = 0.0
+  axis = -1
+```
+
+Then output is `[2 x 2 x 3]`:
+
+    ```output =
+      [
+        [1.0, 0.0, 0.0]  // one_hot(0)
+        [0.0, 0.0, 1.0]  // one_hot(2)
+      ][
+        [0.0, 1.0, 0.0]  // one_hot(1)
+        [0.0, 0.0, 0.0]  // one_hot(-1)
+      ]```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_OneShotIterator.pbtxt b/tensorflow/core/api_def/base_api/api_def_OneShotIterator.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9040f2d9823ff7c5b7c930ff4d729bef0cabe4e9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_OneShotIterator.pbtxt
@@ -0,0 +1,37 @@
+op {
+  graph_op_name: "OneShotIterator"
+  out_arg {
+    name: "handle"
+    description: <<END
+A handle to the iterator that can be passed to an "IteratorGetNext"
+op.
+END
+  }
+  attr {
+    name: "dataset_factory"
+    description: <<END
+A function of type `() -> DT_VARIANT`, where the returned
+DT_VARIANT is a dataset.
+END
+  }
+  summary: "Makes a \"one-shot\" iterator that can be iterated only once."
+  description: <<END
+A one-shot iterator bundles the logic for defining the dataset and
+the state of the iterator in a single op, which allows simple input
+pipelines to be defined without an additional initialization
+("MakeIterator") step.
+
+One-shot iterators have the following limitations:
+
+* They do not support parameterization: all logic for creating the underlying
+  dataset must be bundled in the `dataset_factory` function.
+* They are not resettable. Once a one-shot iterator reaches the end of its
+  underlying dataset, subsequent "IteratorGetNext" operations on that
+  iterator will always produce an `OutOfRange` error.
+
+For greater flexibility, use "Iterator" and "MakeIterator" to define
+an iterator using an arbitrary subgraph, which may capture tensors
+(including fed values) as parameters, and which may be reset multiple
+times by rerunning "MakeIterator".
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_OnesLike.pbtxt b/tensorflow/core/api_def/base_api/api_def_OnesLike.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7c640ab84e14ef41c6bebbedc1f8d3d41a7bc001
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_OnesLike.pbtxt
@@ -0,0 +1,16 @@
+op {
+  graph_op_name: "OnesLike"
+  in_arg {
+    name: "x"
+    description: <<END
+a tensor of type T.
+END
+  }
+  out_arg {
+    name: "y"
+    description: <<END
+a tensor of the same shape and type as x but filled with ones.
+END
+  }
+  summary: "Returns a tensor of ones with the same shape and type as x."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_OrderedMapClear.pbtxt b/tensorflow/core/api_def/base_api/api_def_OrderedMapClear.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8af5a8237447dd7a6a144691aae0fa0fa5008530
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_OrderedMapClear.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "OrderedMapClear"
+  summary: "Op removes all elements in the underlying container."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_OrderedMapIncompleteSize.pbtxt b/tensorflow/core/api_def/base_api/api_def_OrderedMapIncompleteSize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1cb89477aba7c699993a62d9abde5c759318d64b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_OrderedMapIncompleteSize.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "OrderedMapIncompleteSize"
+  summary: "Op returns the number of incomplete elements in the underlying container."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_OrderedMapPeek.pbtxt b/tensorflow/core/api_def/base_api/api_def_OrderedMapPeek.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bafdd425e2f2de0829518fdda19fbd7f366aa90f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_OrderedMapPeek.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "OrderedMapPeek"
+  summary: "Op peeks at the values at the specified key.  If the"
+  description: <<END
+underlying container does not contain this key
+this op will block until it does.   This Op is optimized for
+performance.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_OrderedMapSize.pbtxt b/tensorflow/core/api_def/base_api/api_def_OrderedMapSize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c5bad3012cc93378783100b3419fdbcf4da6681e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_OrderedMapSize.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "OrderedMapSize"
+  summary: "Op returns the number of elements in the underlying container."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_OrderedMapStage.pbtxt b/tensorflow/core/api_def/base_api/api_def_OrderedMapStage.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..dad0b27601fe0bf7a0ebe3acda347de936b5d7a4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_OrderedMapStage.pbtxt
@@ -0,0 +1,40 @@
+op {
+  graph_op_name: "OrderedMapStage"
+  in_arg {
+    name: "key"
+    description: <<END
+int64
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+a list of tensors
+dtypes A list of data types that inserted values should adhere to.
+END
+  }
+  attr {
+    name: "capacity"
+    description: <<END
+Maximum number of elements in the Staging Area. If > 0, inserts
+on the container will block when the capacity is reached.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this queue is placed in the given container. Otherwise,
+a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+It is necessary to match this name to the matching Unstage Op.
+END
+  }
+  summary: "Stage (key, values) in the underlying container which behaves like a ordered"
+  description: <<END
+associative container.   Elements are ordered by key.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_OrderedMapUnstage.pbtxt b/tensorflow/core/api_def/base_api/api_def_OrderedMapUnstage.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..731f1ac6cc76fe62e068606b0bcb76c8ae6eb89e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_OrderedMapUnstage.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "OrderedMapUnstage"
+  summary: "Op removes and returns the values associated with the key"
+  description: <<END
+from the underlying container.   If the underlying container
+does not contain this key, the op will block until it does.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_OrderedMapUnstageNoKey.pbtxt b/tensorflow/core/api_def/base_api/api_def_OrderedMapUnstageNoKey.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ca517a1331fd608142e366a9c0c166591da52ec3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_OrderedMapUnstageNoKey.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "OrderedMapUnstageNoKey"
+  summary: "Op removes and returns the (key, value) element with the smallest"
+  description: <<END
+key from the underlying container.   If the underlying container
+does not contain elements, the op will block until it does.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_P.pbtxt b/tensorflow/core/api_def/base_api/api_def_P.pbtxt
deleted file mode 100644
index a3abb079e95e07c5c13e19b36ba6582ade14f84c..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_P.pbtxt
+++ /dev/null
@@ -1,431 +0,0 @@
-op {
-  graph_op_name: "Pack"
-  endpoint {
-    name: "Pack"
-  }
-  summary: "Packs a list of `N` rank-`R` tensors into one rank-`(R+1)` tensor."
-  description: <<END
-Packs the `N` tensors in `values` into a tensor with rank one higher than each
-tensor in `values`, by packing them along the `axis` dimension.
-Given a list of tensors of shape `(A, B, C)`;
-
-if `axis == 0` then the `output` tensor will have the shape `(N, A, B, C)`.
-if `axis == 1` then the `output` tensor will have the shape `(A, N, B, C)`.
-Etc.
-
-For example:
-
-```
-# 'x' is [1, 4]
-# 'y' is [2, 5]
-# 'z' is [3, 6]
-pack([x, y, z]) => [[1, 4], [2, 5], [3, 6]]  # Pack along first dim.
-pack([x, y, z], axis=1) => [[1, 2, 3], [4, 5, 6]]
-```
-
-This is the opposite of `unpack`.
-END
-}
-op {
-  graph_op_name: "Pad"
-  endpoint {
-    name: "Pad"
-  }
-  summary: "Pads a tensor with zeros."
-  description: <<END
-This operation pads a `input` with zeros according to the `paddings` you
-specify. `paddings` is an integer tensor with shape `[Dn, 2]`, where n is the
-rank of `input`. For each dimension D of `input`, `paddings[D, 0]` indicates
-how many zeros to add before the contents of `input` in that dimension, and
-`paddings[D, 1]` indicates how many zeros to add after the contents of `input`
-in that dimension.
-
-The padded size of each dimension D of the output is:
-
-`paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
-
-For example:
-
-```
-# 't' is [[1, 1], [2, 2]]
-# 'paddings' is [[1, 1], [2, 2]]
-# rank of 't' is 2
-pad(t, paddings) ==> [[0, 0, 0, 0, 0, 0]
-                      [0, 0, 1, 1, 0, 0]
-                      [0, 0, 2, 2, 0, 0]
-                      [0, 0, 0, 0, 0, 0]]
-```
-END
-}
-op {
-  graph_op_name: "PadV2"
-  endpoint {
-    name: "PadV2"
-  }
-  summary: "Pads a tensor."
-  description: <<END
-This operation pads `input` according to the `paddings` and `constant_values`
-you specify. `paddings` is an integer tensor with shape `[Dn, 2]`, where n is
-the rank of `input`. For each dimension D of `input`, `paddings[D, 0]` indicates
-how many padding values to add before the contents of `input` in that dimension,
-and `paddings[D, 1]` indicates how many padding values to add after the contents
-of `input` in that dimension. `constant_values` is a scalar tensor of the same
-type as `input` that indicates the value to use for padding `input`.
-
-The padded size of each dimension D of the output is:
-
-`paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
-
-For example:
-
-```
-# 't' is [[1, 1], [2, 2]]
-# 'paddings' is [[1, 1], [2, 2]]
-# 'constant_values' is 0
-# rank of 't' is 2
-pad(t, paddings) ==> [[0, 0, 0, 0, 0, 0]
-                      [0, 0, 1, 1, 0, 0]
-                      [0, 0, 2, 2, 0, 0]
-                      [0, 0, 0, 0, 0, 0]]
-```
-END
-}
-op {
-  graph_op_name: "PaddedBatchDataset"
-  endpoint {
-    name: "PaddedBatchDataset"
-  }
-  summary: "Creates a dataset that batches and pads `batch_size` elements from the input."
-}
-op {
-  graph_op_name: "PaddingFIFOQueue"
-  endpoint {
-    name: "PaddingFIFOQueue"
-  }
-  summary: "A queue that produces elements in first-in first-out order."
-  description: <<END
-Variable-size shapes are allowed by setting the corresponding shape dimensions
-to 0 in the shape attr.  In this case DequeueMany will pad up to the maximum
-size of any given element in the minibatch.  See below for details.
-END
-}
-op {
-  graph_op_name: "PaddingFIFOQueueV2"
-  endpoint {
-    name: "PaddingFIFOQueueV2"
-  }
-  summary: "A queue that produces elements in first-in first-out order."
-  description: <<END
-Variable-size shapes are allowed by setting the corresponding shape dimensions
-to 0 in the shape attr.  In this case DequeueMany will pad up to the maximum
-size of any given element in the minibatch.  See below for details.
-END
-}
-op {
-  graph_op_name: "ParallelConcat"
-  endpoint {
-    name: "ParallelConcat"
-  }
-  summary: "Concatenates a list of `N` tensors along the first dimension."
-  description: <<END
-The input tensors are all required to have size 1 in the first dimension.
-
-For example:
-
-```
-# 'x' is [[1, 4]]
-# 'y' is [[2, 5]]
-# 'z' is [[3, 6]]
-parallel_concat([x, y, z]) => [[1, 4], [2, 5], [3, 6]]  # Pack along first dim.
-```
-
-The difference between concat and parallel_concat is that concat requires all
-of the inputs be computed before the operation will begin but doesn't require
-that the input shapes be known during graph construction.  Parallel concat
-will copy pieces of the input into the output as they become available, in
-some situations this can provide a performance benefit.
-END
-}
-op {
-  graph_op_name: "ParallelDynamicStitch"
-  endpoint {
-    name: "ParallelDynamicStitch"
-  }
-  summary: "Interleave the values from the `data` tensors into a single tensor."
-  description: <<END
-Builds a merged tensor such that
-
-```python
-    merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]
-```
-
-For example, if each `indices[m]` is scalar or vector, we have
-
-```python
-    # Scalar indices:
-    merged[indices[m], ...] = data[m][...]
-
-    # Vector indices:
-    merged[indices[m][i], ...] = data[m][i, ...]
-```
-
-Each `data[i].shape` must start with the corresponding `indices[i].shape`,
-and the rest of `data[i].shape` must be constant w.r.t. `i`.  That is, we
-must have `data[i].shape = indices[i].shape + constant`.  In terms of this
-`constant`, the output shape is
-
-    merged.shape = [max(indices)] + constant
-
-Values may be merged in parallel, so if an index appears in both `indices[m][i]`
-and `indices[n][j]`, the result may be invalid. This differs from the normal
-DynamicStitch operator that defines the behavior in that case.
-
-For example:
-
-```python
-    indices[0] = 6
-    indices[1] = [4, 1]
-    indices[2] = [[5, 2], [0, 3]]
-    data[0] = [61, 62]
-    data[1] = [[41, 42], [11, 12]]
-    data[2] = [[[51, 52], [21, 22]], [[1, 2], [31, 32]]]
-    merged = [[1, 2], [11, 12], [21, 22], [31, 32], [41, 42],
-              [51, 52], [61, 62]]
-```
-
-This method can be used to merge partitions created by `dynamic_partition`
-as illustrated on the following example:
-
-```python
-    # Apply function (increments x_i) on elements for which a certain condition
-    # apply (x_i != -1 in this example).
-    x=tf.constant([0.1, -1., 5.2, 4.3, -1., 7.4])
-    condition_mask=tf.not_equal(x,tf.constant(-1.))
-    partitioned_data = tf.dynamic_partition(
-        x, tf.cast(condition_mask, tf.int32) , 2)
-    partitioned_data[1] = partitioned_data[1] + 1.0
-    condition_indices = tf.dynamic_partition(
-        tf.range(tf.shape(x)[0]), tf.cast(condition_mask, tf.int32) , 2)
-    x = tf.dynamic_stitch(condition_indices, partitioned_data)
-    # Here x=[1.1, -1., 6.2, 5.3, -1, 8.4], the -1. values remain
-    # unchanged.
-```
-
-<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-<img style="width:100%" src="https://www.tensorflow.org/images/DynamicStitch.png" alt>
-</div>
-END
-}
-op {
-  graph_op_name: "ParallelMapDataset"
-  endpoint {
-    name: "ParallelMapDataset"
-  }
-  summary: "Creates a dataset that applies `f` to the outputs of `input_dataset`."
-  description: <<END
-Unlike a "MapDataset", which applies `f` sequentially, this dataset invokes up
-to `num_parallel_calls` copies of `f` in parallel.
-END
-}
-op {
-  graph_op_name: "ParameterizedTruncatedNormal"
-  endpoint {
-    name: "ParameterizedTruncatedNormal"
-  }
-  summary: "Outputs random values from a normal distribution. The parameters may each be a"
-  description: <<END
-scalar which applies to the entire output, or a vector of length shape[0] which
-stores the parameters for each batch.
-END
-}
-op {
-  graph_op_name: "ParseExample"
-  endpoint {
-    name: "ParseExample"
-  }
-  summary: "Transforms a vector of brain.Example protos (as strings) into typed tensors."
-}
-op {
-  graph_op_name: "ParseSingleSequenceExample"
-  endpoint {
-    name: "ParseSingleSequenceExample"
-  }
-  summary: "Transforms a scalar brain.SequenceExample proto (as strings) into typed tensors."
-}
-op {
-  graph_op_name: "ParseTensor"
-  endpoint {
-    name: "ParseTensor"
-  }
-  summary: "Transforms a serialized tensorflow.TensorProto proto into a Tensor."
-}
-op {
-  graph_op_name: "Placeholder"
-  endpoint {
-    name: "Placeholder"
-  }
-  summary: "A placeholder op for a value that will be fed into the computation."
-  description: <<END
-N.B. This operation will fail with an error if it is executed. It is
-intended as a way to represent a value that will always be fed, and to
-provide attrs that enable the fed value to be checked at runtime.
-END
-}
-op {
-  graph_op_name: "PlaceholderV2"
-  endpoint {
-    name: "PlaceholderV2"
-  }
-  summary: "A placeholder op for a value that will be fed into the computation."
-  description: <<END
-N.B. This operation will fail with an error if it is executed. It is
-intended as a way to represent a value that will always be fed, and to
-provide attrs that enable the fed value to be checked at runtime.
-END
-}
-op {
-  graph_op_name: "PlaceholderWithDefault"
-  endpoint {
-    name: "PlaceholderWithDefault"
-  }
-  summary: "A placeholder op that passes through `input` when its output is not fed."
-}
-op {
-  graph_op_name: "Polygamma"
-  endpoint {
-    name: "Polygamma"
-  }
-  summary: "Compute the polygamma function \\\\(\\psi^{(n)}(x)\\\\)."
-  description: <<END
-The polygamma function is defined as:
-
-
-\\(\psi^{(n)}(x) = \frac{d^n}{dx^n} \psi(x)\\)
-
-where \\(\psi(x)\\) is the digamma function.
-END
-}
-op {
-  graph_op_name: "PopulationCount"
-  endpoint {
-    name: "PopulationCount"
-  }
-  summary: "Computes element-wise population count (a.k.a. popcount, bitsum, bitcount)."
-  description: <<END
-For each entry in `x`, calculates the number of `1` (on) bits in the binary
-representation of that entry.
-
-**NOTE**: It is more efficient to first `tf.bitcast` your tensors into
-`int32` or `int64` and perform the bitcount on the result, than to feed in
-8- or 16-bit inputs and then aggregate the resulting counts.
-END
-}
-op {
-  graph_op_name: "Pow"
-  endpoint {
-    name: "Pow"
-  }
-  summary: "Computes the power of one value to another."
-  description: <<END
-Given a tensor `x` and a tensor `y`, this operation computes \\(x^y\\) for
-corresponding elements in `x` and `y`. For example:
-
-```
-# tensor 'x' is [[2, 2]], [3, 3]]
-# tensor 'y' is [[8, 16], [2, 3]]
-tf.pow(x, y) ==> [[256, 65536], [9, 27]]
-```
-END
-}
-op {
-  graph_op_name: "PrefetchDataset"
-  endpoint {
-    name: "PrefetchDataset"
-  }
-  summary: "Creates a dataset that asynchronously prefetches elements from `input_dataset`."
-}
-op {
-  graph_op_name: "PreventGradient"
-  endpoint {
-    name: "PreventGradient"
-  }
-  summary: "An identity op that triggers an error if a gradient is requested."
-  description: <<END
-When executed in a graph, this op outputs its input tensor as-is.
-
-When building ops to compute gradients, the TensorFlow gradient system
-will return an error when trying to lookup the gradient of this op,
-because no gradient must ever be registered for this function.  This
-op exists to prevent subtle bugs from silently returning unimplemented
-gradients in some corner cases.
-END
-}
-op {
-  graph_op_name: "Print"
-  endpoint {
-    name: "Print"
-  }
-  summary: "Prints a list of tensors."
-  description: <<END
-Passes `input` through to `output` and prints `data` when evaluating.
-END
-}
-op {
-  graph_op_name: "PriorityQueue"
-  endpoint {
-    name: "PriorityQueue"
-  }
-  summary: "A queue that produces elements sorted by the first component value."
-  description: <<END
-Note that the PriorityQueue requires the first component of any element
-to be a scalar int64, in addition to the other elements declared by
-component_types.  Therefore calls to Enqueue and EnqueueMany (resp. Dequeue
-and DequeueMany) on a PriorityQueue will all require (resp. output) one extra
-entry in their input (resp. output) lists.
-END
-}
-op {
-  graph_op_name: "PriorityQueueV2"
-  endpoint {
-    name: "PriorityQueueV2"
-  }
-  summary: "A queue that produces elements sorted by the first component value."
-  description: <<END
-Note that the PriorityQueue requires the first component of any element
-to be a scalar int64, in addition to the other elements declared by
-component_types.  Therefore calls to Enqueue and EnqueueMany (resp. Dequeue
-and DequeueMany) on a PriorityQueue will all require (resp. output) one extra
-entry in their input (resp. output) lists.
-END
-}
-op {
-  graph_op_name: "Prod"
-  endpoint {
-    name: "Prod"
-  }
-  summary: "Computes the product of elements across dimensions of a tensor."
-  description: <<END
-Reduces `input` along the dimensions given in `reduction_indices`. Unless
-`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-`reduction_indices`. If `keep_dims` is true, the reduced dimensions are
-retained with length 1.
-END
-}
-op {
-  graph_op_name: "PyFunc"
-  endpoint {
-    name: "PyFunc"
-  }
-  summary: "Invokes a python function to compute func(input)->output."
-  description: <<END
-This operation is considered stateful. For a stateless version, see
-PyFuncStateless.
-END
-}
-op {
-  graph_op_name: "PyFuncStateless"
-  endpoint {
-    name: "PyFuncStateless"
-  }
-  summary: "A stateless version of PyFunc."
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_Pack.pbtxt b/tensorflow/core/api_def/base_api/api_def_Pack.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..106ca3cd86fafa3affb2e1e99de68ad95224a862
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Pack.pbtxt
@@ -0,0 +1,47 @@
+op {
+  graph_op_name: "Pack"
+  endpoint {
+    name: "Stack"
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+Must be of same shape and type.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The packed tensor.
+END
+  }
+  attr {
+    name: "axis"
+    description: <<END
+Dimension along which to pack.  Negative values wrap around, so the
+valid range is `[-(R+1), R+1)`.
+END
+  }
+  summary: "Packs a list of `N` rank-`R` tensors into one rank-`(R+1)` tensor."
+  description: <<END
+Packs the `N` tensors in `values` into a tensor with rank one higher than each
+tensor in `values`, by packing them along the `axis` dimension.
+Given a list of tensors of shape `(A, B, C)`;
+
+if `axis == 0` then the `output` tensor will have the shape `(N, A, B, C)`.
+if `axis == 1` then the `output` tensor will have the shape `(A, N, B, C)`.
+Etc.
+
+For example:
+
+```
+# 'x' is [1, 4]
+# 'y' is [2, 5]
+# 'z' is [3, 6]
+pack([x, y, z]) => [[1, 4], [2, 5], [3, 6]]  # Pack along first dim.
+pack([x, y, z], axis=1) => [[1, 2, 3], [4, 5, 6]]
+```
+
+This is the opposite of `unpack`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Pad.pbtxt b/tensorflow/core/api_def/base_api/api_def_Pad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e45e2375eb9eb732712ab3bde5b33ac6de884e09
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Pad.pbtxt
@@ -0,0 +1,28 @@
+op {
+  graph_op_name: "Pad"
+  summary: "Pads a tensor with zeros."
+  description: <<END
+This operation pads a `input` with zeros according to the `paddings` you
+specify. `paddings` is an integer tensor with shape `[Dn, 2]`, where n is the
+rank of `input`. For each dimension D of `input`, `paddings[D, 0]` indicates
+how many zeros to add before the contents of `input` in that dimension, and
+`paddings[D, 1]` indicates how many zeros to add after the contents of `input`
+in that dimension.
+
+The padded size of each dimension D of the output is:
+
+`paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
+
+For example:
+
+```
+# 't' is [[1, 1], [2, 2]]
+# 'paddings' is [[1, 1], [2, 2]]
+# rank of 't' is 2
+pad(t, paddings) ==> [[0, 0, 0, 0, 0, 0]
+                      [0, 0, 1, 1, 0, 0]
+                      [0, 0, 2, 2, 0, 0]
+                      [0, 0, 0, 0, 0, 0]]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_PadV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_PadV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7e2765764e20a8a4ccf8f05900c46b96aaaddc97
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_PadV2.pbtxt
@@ -0,0 +1,30 @@
+op {
+  graph_op_name: "PadV2"
+  summary: "Pads a tensor."
+  description: <<END
+This operation pads `input` according to the `paddings` and `constant_values`
+you specify. `paddings` is an integer tensor with shape `[Dn, 2]`, where n is
+the rank of `input`. For each dimension D of `input`, `paddings[D, 0]` indicates
+how many padding values to add before the contents of `input` in that dimension,
+and `paddings[D, 1]` indicates how many padding values to add after the contents
+of `input` in that dimension. `constant_values` is a scalar tensor of the same
+type as `input` that indicates the value to use for padding `input`.
+
+The padded size of each dimension D of the output is:
+
+`paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
+
+For example:
+
+```
+# 't' is [[1, 1], [2, 2]]
+# 'paddings' is [[1, 1], [2, 2]]
+# 'constant_values' is 0
+# rank of 't' is 2
+pad(t, paddings) ==> [[0, 0, 0, 0, 0, 0]
+                      [0, 0, 1, 1, 0, 0]
+                      [0, 0, 2, 2, 0, 0]
+                      [0, 0, 0, 0, 0, 0]]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_PaddedBatchDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_PaddedBatchDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d243dfe8b67bc14e9c5e22d5e68e3faf5d4684a8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_PaddedBatchDataset.pbtxt
@@ -0,0 +1,27 @@
+op {
+  graph_op_name: "PaddedBatchDataset"
+  in_arg {
+    name: "batch_size"
+    description: <<END
+A scalar representing the number of elements to accumulate in a
+batch.
+END
+  }
+  in_arg {
+    name: "padded_shapes"
+    description: <<END
+A list of int64 tensors representing the desired padded shapes
+of the corresponding output components. These shapes may be partially
+specified, using `-1` to indicate that a particular dimension should be
+padded to the maximum size of all batch elements.
+END
+  }
+  in_arg {
+    name: "padding_values"
+    description: <<END
+A list of scalars containing the padding value to use for
+each of the outputs.
+END
+  }
+  summary: "Creates a dataset that batches and pads `batch_size` elements from the input."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_PaddingFIFOQueue.pbtxt b/tensorflow/core/api_def/base_api/api_def_PaddingFIFOQueue.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3b6671a2f126f470a70ceda86240645472351a8e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_PaddingFIFOQueue.pbtxt
@@ -0,0 +1,56 @@
+op {
+  graph_op_name: "PaddingFIFOQueue"
+  visibility: SKIP
+  out_arg {
+    name: "handle"
+    description: <<END
+The handle to the queue.
+END
+  }
+  attr {
+    name: "component_types"
+    description: <<END
+The type of each component in a value.
+END
+  }
+  attr {
+    name: "shapes"
+    description: <<END
+The shape of each component in a value. The length of this attr must
+be either 0 or the same as the length of component_types.
+Shapes of fixed rank but variable size are allowed by setting
+any shape dimension to -1.  In this case, the inputs' shape may vary along
+the given dimension, and DequeueMany will pad the given dimension with
+zeros up to the maximum shape of all elements in the given batch.
+If the length of this attr is 0, different queue elements may have
+different ranks and shapes, but only one element may be dequeued at a time.
+END
+  }
+  attr {
+    name: "capacity"
+    description: <<END
+The upper bound on the number of elements in this queue.
+Negative numbers mean no limit.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this queue is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this queue will be shared under the given name
+across multiple sessions.
+END
+  }
+  summary: "A queue that produces elements in first-in first-out order."
+  description: <<END
+Variable-size shapes are allowed by setting the corresponding shape dimensions
+to 0 in the shape attr.  In this case DequeueMany will pad up to the maximum
+size of any given element in the minibatch.  See below for details.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_PaddingFIFOQueueV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_PaddingFIFOQueueV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b65be6f4f5c0c37e855c61ed44a4b348bd95b98d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_PaddingFIFOQueueV2.pbtxt
@@ -0,0 +1,58 @@
+op {
+  graph_op_name: "PaddingFIFOQueueV2"
+  endpoint {
+    name: "PaddingFIFOQueue"
+  }
+  out_arg {
+    name: "handle"
+    description: <<END
+The handle to the queue.
+END
+  }
+  attr {
+    name: "component_types"
+    description: <<END
+The type of each component in a value.
+END
+  }
+  attr {
+    name: "shapes"
+    description: <<END
+The shape of each component in a value. The length of this attr must
+be either 0 or the same as the length of component_types.
+Shapes of fixed rank but variable size are allowed by setting
+any shape dimension to -1.  In this case, the inputs' shape may vary along
+the given dimension, and DequeueMany will pad the given dimension with
+zeros up to the maximum shape of all elements in the given batch.
+If the length of this attr is 0, different queue elements may have
+different ranks and shapes, but only one element may be dequeued at a time.
+END
+  }
+  attr {
+    name: "capacity"
+    description: <<END
+The upper bound on the number of elements in this queue.
+Negative numbers mean no limit.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this queue is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this queue will be shared under the given name
+across multiple sessions.
+END
+  }
+  summary: "A queue that produces elements in first-in first-out order."
+  description: <<END
+Variable-size shapes are allowed by setting the corresponding shape dimensions
+to 0 in the shape attr.  In this case DequeueMany will pad up to the maximum
+size of any given element in the minibatch.  See below for details.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ParallelConcat.pbtxt b/tensorflow/core/api_def/base_api/api_def_ParallelConcat.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9cf2449c9f810b65bc1b418a92b01d681a7e34d8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ParallelConcat.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "ParallelConcat"
+  in_arg {
+    name: "values"
+    description: <<END
+Tensors to be concatenated. All must have size 1 in the first dimension
+and same shape.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The concatenated tensor.
+END
+  }
+  attr {
+    name: "shape"
+    description: <<END
+the final shape of the result; should be equal to the shapes of any input
+but with the number of input values in the first dimension.
+END
+  }
+  summary: "Concatenates a list of `N` tensors along the first dimension."
+  description: <<END
+The input tensors are all required to have size 1 in the first dimension.
+
+For example:
+
+```
+# 'x' is [[1, 4]]
+# 'y' is [[2, 5]]
+# 'z' is [[3, 6]]
+parallel_concat([x, y, z]) => [[1, 4], [2, 5], [3, 6]]  # Pack along first dim.
+```
+
+The difference between concat and parallel_concat is that concat requires all
+of the inputs be computed before the operation will begin but doesn't require
+that the input shapes be known during graph construction.  Parallel concat
+will copy pieces of the input into the output as they become available, in
+some situations this can provide a performance benefit.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ParallelDynamicStitch.pbtxt b/tensorflow/core/api_def/base_api/api_def_ParallelDynamicStitch.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9404a4dee098b27ab25d1ed7d60e954e4e120710
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ParallelDynamicStitch.pbtxt
@@ -0,0 +1,67 @@
+op {
+  graph_op_name: "ParallelDynamicStitch"
+  summary: "Interleave the values from the `data` tensors into a single tensor."
+  description: <<END
+Builds a merged tensor such that
+
+```python
+    merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]
+```
+
+For example, if each `indices[m]` is scalar or vector, we have
+
+```python
+    # Scalar indices:
+    merged[indices[m], ...] = data[m][...]
+
+    # Vector indices:
+    merged[indices[m][i], ...] = data[m][i, ...]
+```
+
+Each `data[i].shape` must start with the corresponding `indices[i].shape`,
+and the rest of `data[i].shape` must be constant w.r.t. `i`.  That is, we
+must have `data[i].shape = indices[i].shape + constant`.  In terms of this
+`constant`, the output shape is
+
+    merged.shape = [max(indices)] + constant
+
+Values may be merged in parallel, so if an index appears in both `indices[m][i]`
+and `indices[n][j]`, the result may be invalid. This differs from the normal
+DynamicStitch operator that defines the behavior in that case.
+
+For example:
+
+```python
+    indices[0] = 6
+    indices[1] = [4, 1]
+    indices[2] = [[5, 2], [0, 3]]
+    data[0] = [61, 62]
+    data[1] = [[41, 42], [11, 12]]
+    data[2] = [[[51, 52], [21, 22]], [[1, 2], [31, 32]]]
+    merged = [[1, 2], [11, 12], [21, 22], [31, 32], [41, 42],
+              [51, 52], [61, 62]]
+```
+
+This method can be used to merge partitions created by `dynamic_partition`
+as illustrated on the following example:
+
+```python
+    # Apply function (increments x_i) on elements for which a certain condition
+    # apply (x_i != -1 in this example).
+    x=tf.constant([0.1, -1., 5.2, 4.3, -1., 7.4])
+    condition_mask=tf.not_equal(x,tf.constant(-1.))
+    partitioned_data = tf.dynamic_partition(
+        x, tf.cast(condition_mask, tf.int32) , 2)
+    partitioned_data[1] = partitioned_data[1] + 1.0
+    condition_indices = tf.dynamic_partition(
+        tf.range(tf.shape(x)[0]), tf.cast(condition_mask, tf.int32) , 2)
+    x = tf.dynamic_stitch(condition_indices, partitioned_data)
+    # Here x=[1.1, -1., 6.2, 5.3, -1, 8.4], the -1. values remain
+    # unchanged.
+```
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src="https://www.tensorflow.org/images/DynamicStitch.png" alt>
+</div>
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ParallelInterleaveDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_ParallelInterleaveDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d6889b54a032bb20896dc7b03af5621f45d365d9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ParallelInterleaveDataset.pbtxt
@@ -0,0 +1,21 @@
+op {
+  graph_op_name: "ParallelInterleaveDataset"
+  attr {
+    name: "f"
+    description: <<END
+A function mapping elements of `input_dataset`, concatenated with
+`other_arguments`, to a Dataset variant that contains elements matching
+`output_types` and `output_shapes`.
+END
+  }
+  summary: "Creates a dataset that applies `f` to the outputs of `input_dataset`."
+  description: <<END
+The resulting dataset is similar to the `InterleaveDataset`, with the exception
+that if retrieving the next value from a dataset would cause the requester to
+block, it will skip that input dataset. This dataset is especially useful
+when loading data from a variable-latency datastores (e.g. HDFS, GCS), as it
+allows the training step to proceed so long as some data is available.
+
+!! WARNING !! This dataset is not deterministic!
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ParallelMapDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_ParallelMapDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..313494dd738b02d09807ec78fc8e0802e719e116
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ParallelMapDataset.pbtxt
@@ -0,0 +1,15 @@
+op {
+  graph_op_name: "ParallelMapDataset"
+  in_arg {
+    name: "num_parallel_calls"
+    description: <<END
+The number of concurrent invocations of `f` that process
+elements from `input_dataset` in parallel.
+END
+  }
+  summary: "Creates a dataset that applies `f` to the outputs of `input_dataset`."
+  description: <<END
+Unlike a "MapDataset", which applies `f` sequentially, this dataset invokes up
+to `num_parallel_calls` copies of `f` in parallel.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ParameterizedTruncatedNormal.pbtxt b/tensorflow/core/api_def/base_api/api_def_ParameterizedTruncatedNormal.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a01c39a96ad83f98b039682e04df55221c1e0ecb
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ParameterizedTruncatedNormal.pbtxt
@@ -0,0 +1,66 @@
+op {
+  graph_op_name: "ParameterizedTruncatedNormal"
+  in_arg {
+    name: "shape"
+    description: <<END
+The shape of the output tensor. Batches are indexed by the 0th dimension.
+END
+  }
+  in_arg {
+    name: "means"
+    description: <<END
+The mean parameter of each batch.
+END
+  }
+  in_arg {
+    name: "stdevs"
+    description: <<END
+The standard deviation parameter of each batch. Must be greater than 0.
+END
+  }
+  in_arg {
+    name: "minvals"
+    description: <<END
+The minimum cutoff. May be -infinity.
+END
+  }
+  in_arg {
+    name: "maxvals"
+    description: <<END
+The maximum cutoff. May be +infinity, and must be more than the minval
+for each batch.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A matrix of shape num_batches x samples_per_batch, filled with random
+truncated normal values using the parameters for each row.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either `seed` or `seed2` are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+A second seed to avoid seed collision.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of the output.
+END
+  }
+  summary: "Outputs random values from a normal distribution. The parameters may each be a"
+  description: <<END
+scalar which applies to the entire output, or a vector of length shape[0] which
+stores the parameters for each batch.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ParseExample.pbtxt b/tensorflow/core/api_def/base_api/api_def_ParseExample.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4f404206ecf91083cb4e233bf18d30b5bd44e9c6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ParseExample.pbtxt
@@ -0,0 +1,78 @@
+op {
+  graph_op_name: "ParseExample"
+  in_arg {
+    name: "serialized"
+    description: <<END
+A vector containing a batch of binary serialized Example protos.
+END
+  }
+  in_arg {
+    name: "names"
+    description: <<END
+A vector containing the names of the serialized protos.
+May contain, for example, table key (descriptive) names for the
+corresponding serialized protos.  These are purely useful for debugging
+purposes, and the presence of values here has no effect on the output.
+May also be an empty vector if no names are available.
+If non-empty, this vector must be the same length as "serialized".
+END
+  }
+  in_arg {
+    name: "sparse_keys"
+    description: <<END
+A list of Nsparse string Tensors (scalars).
+The keys expected in the Examples' features associated with sparse values.
+END
+  }
+  in_arg {
+    name: "dense_keys"
+    description: <<END
+A list of Ndense string Tensors (scalars).
+The keys expected in the Examples' features associated with dense values.
+END
+  }
+  in_arg {
+    name: "dense_defaults"
+    description: <<END
+A list of Ndense Tensors (some may be empty).
+dense_defaults[j] provides default values
+when the example's feature_map lacks dense_key[j].  If an empty Tensor is
+provided for dense_defaults[j], then the Feature dense_keys[j] is required.
+The input type is inferred from dense_defaults[j], even when it's empty.
+If dense_defaults[j] is not empty, and dense_shapes[j] is fully defined,
+then the shape of dense_defaults[j] must match that of dense_shapes[j].
+If dense_shapes[j] has an undefined major dimension (variable strides dense
+feature), dense_defaults[j] must contain a single element:
+the padding element.
+END
+  }
+  attr {
+    name: "sparse_types"
+    description: <<END
+A list of Nsparse types; the data types of data in each Feature
+given in sparse_keys.
+Currently the ParseExample supports DT_FLOAT (FloatList),
+DT_INT64 (Int64List), and DT_STRING (BytesList).
+END
+  }
+  attr {
+    name: "dense_shapes"
+    description: <<END
+A list of Ndense shapes; the shapes of data in each Feature
+given in dense_keys.
+The number of elements in the Feature corresponding to dense_key[j]
+must always equal dense_shapes[j].NumEntries().
+If dense_shapes[j] == (D0, D1, ..., DN) then the shape of output
+Tensor dense_values[j] will be (|serialized|, D0, D1, ..., DN):
+The dense outputs are just the inputs row-stacked by batch.
+This works for dense_shapes[j] = (-1, D1, ..., DN).  In this case
+the shape of the output Tensor dense_values[j] will be
+(|serialized|, M, D1, .., DN), where M is the maximum number of blocks
+of elements of length D1 * .... * DN, across all minibatch entries
+in the input.  Any minibatch entry with less than M blocks of elements of
+length D1 * ... * DN will be padded with the corresponding default_value
+scalar element along the second dimension.
+END
+  }
+  summary: "Transforms a vector of brain.Example protos (as strings) into typed tensors."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ParseSingleSequenceExample.pbtxt b/tensorflow/core/api_def/base_api/api_def_ParseSingleSequenceExample.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a087c11d469ed406b3036076e9b5b6c51f5d2d75
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ParseSingleSequenceExample.pbtxt
@@ -0,0 +1,112 @@
+op {
+  graph_op_name: "ParseSingleSequenceExample"
+  in_arg {
+    name: "serialized"
+    description: <<END
+A scalar containing a binary serialized SequenceExample proto.
+END
+  }
+  in_arg {
+    name: "feature_list_dense_missing_assumed_empty"
+    description: <<END
+A vector listing the
+FeatureList keys which may be missing from the SequenceExample.  If the
+associated FeatureList is missing, it is treated as empty.  By default,
+any FeatureList not listed in this vector must exist in the SequenceExample.
+END
+  }
+  in_arg {
+    name: "context_sparse_keys"
+    description: <<END
+A list of Ncontext_sparse string Tensors (scalars).
+The keys expected in the Examples' features associated with context_sparse
+values.
+END
+  }
+  in_arg {
+    name: "context_dense_keys"
+    description: <<END
+A list of Ncontext_dense string Tensors (scalars).
+The keys expected in the SequenceExamples' context features associated with
+dense values.
+END
+  }
+  in_arg {
+    name: "feature_list_sparse_keys"
+    description: <<END
+A list of Nfeature_list_sparse string Tensors
+(scalars).  The keys expected in the FeatureLists associated with sparse
+values.
+END
+  }
+  in_arg {
+    name: "feature_list_dense_keys"
+    description: <<END
+A list of Nfeature_list_dense string Tensors (scalars).
+The keys expected in the SequenceExamples' feature_lists associated
+with lists of dense values.
+END
+  }
+  in_arg {
+    name: "context_dense_defaults"
+    description: <<END
+A list of Ncontext_dense Tensors (some may be empty).
+context_dense_defaults[j] provides default values
+when the SequenceExample's context map lacks context_dense_key[j].
+If an empty Tensor is provided for context_dense_defaults[j],
+then the Feature context_dense_keys[j] is required.
+The input type is inferred from context_dense_defaults[j], even when it's
+empty.  If context_dense_defaults[j] is not empty, its shape must match
+context_dense_shapes[j].
+END
+  }
+  in_arg {
+    name: "debug_name"
+    description: <<END
+A scalar containing the name of the serialized proto.
+May contain, for example, table key (descriptive) name for the
+corresponding serialized proto.  This is purely useful for debugging
+purposes, and the presence of values here has no effect on the output.
+May also be an empty scalar if no name is available.
+END
+  }
+  attr {
+    name: "context_sparse_types"
+    description: <<END
+A list of Ncontext_sparse types; the data types of data in
+each context Feature given in context_sparse_keys.
+Currently the ParseSingleSequenceExample supports DT_FLOAT (FloatList),
+DT_INT64 (Int64List), and DT_STRING (BytesList).
+END
+  }
+  attr {
+    name: "context_dense_shapes"
+    description: <<END
+A list of Ncontext_dense shapes; the shapes of data in
+each context Feature given in context_dense_keys.
+The number of elements in the Feature corresponding to context_dense_key[j]
+must always equal context_dense_shapes[j].NumEntries().
+The shape of context_dense_values[j] will match context_dense_shapes[j].
+END
+  }
+  attr {
+    name: "feature_list_sparse_types"
+    description: <<END
+A list of Nfeature_list_sparse types; the data types
+of data in each FeatureList given in feature_list_sparse_keys.
+Currently the ParseSingleSequenceExample supports DT_FLOAT (FloatList),
+DT_INT64 (Int64List), and DT_STRING (BytesList).
+END
+  }
+  attr {
+    name: "feature_list_dense_shapes"
+    description: <<END
+A list of Nfeature_list_dense shapes; the shapes of
+data in each FeatureList given in feature_list_dense_keys.
+The shape of each Feature in the FeatureList corresponding to
+feature_list_dense_key[j] must always equal
+feature_list_dense_shapes[j].NumEntries().
+END
+  }
+  summary: "Transforms a scalar brain.SequenceExample proto (as strings) into typed tensors."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ParseTensor.pbtxt b/tensorflow/core/api_def/base_api/api_def_ParseTensor.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d05efdf09523b1985d980da2623fa210091df0dd
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ParseTensor.pbtxt
@@ -0,0 +1,23 @@
+op {
+  graph_op_name: "ParseTensor"
+  in_arg {
+    name: "serialized"
+    description: <<END
+A scalar string containing a serialized TensorProto proto.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A Tensor of type `out_type`.
+END
+  }
+  attr {
+    name: "out_type"
+    description: <<END
+The type of the serialized tensor.  The provided type must match the
+type of the serialized tensor and no implicit conversion will take place.
+END
+  }
+  summary: "Transforms a serialized tensorflow.TensorProto proto into a Tensor."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Placeholder.pbtxt b/tensorflow/core/api_def/base_api/api_def_Placeholder.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..eb27bc6142480e3340f2e6ff180009161faab0ae
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Placeholder.pbtxt
@@ -0,0 +1,28 @@
+op {
+  graph_op_name: "Placeholder"
+  out_arg {
+    name: "output"
+    description: <<END
+A placeholder tensor that must be replaced using the feed mechanism.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of elements in the tensor.
+END
+  }
+  attr {
+    name: "shape"
+    description: <<END
+(Optional) The shape of the tensor. If the shape has 0 dimensions, the
+shape is unconstrained.
+END
+  }
+  summary: "A placeholder op for a value that will be fed into the computation."
+  description: <<END
+N.B. This operation will fail with an error if it is executed. It is
+intended as a way to represent a value that will always be fed, and to
+provide attrs that enable the fed value to be checked at runtime.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_PlaceholderV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_PlaceholderV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c67f6e12e0b0664cc6ed78b2c2d79c4c5e2544c8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_PlaceholderV2.pbtxt
@@ -0,0 +1,28 @@
+op {
+  graph_op_name: "PlaceholderV2"
+  out_arg {
+    name: "output"
+    description: <<END
+A placeholder tensor that must be replaced using the feed mechanism.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of elements in the tensor.
+END
+  }
+  attr {
+    name: "shape"
+    description: <<END
+The shape of the tensor. The shape can be any partially-specified
+shape.  To be unconstrained, pass in a shape with unknown rank.
+END
+  }
+  summary: "A placeholder op for a value that will be fed into the computation."
+  description: <<END
+N.B. This operation will fail with an error if it is executed. It is
+intended as a way to represent a value that will always be fed, and to
+provide attrs that enable the fed value to be checked at runtime.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_PlaceholderWithDefault.pbtxt b/tensorflow/core/api_def/base_api/api_def_PlaceholderWithDefault.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c20383faf54499a86d64add7b1dca99484637700
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_PlaceholderWithDefault.pbtxt
@@ -0,0 +1,28 @@
+op {
+  graph_op_name: "PlaceholderWithDefault"
+  in_arg {
+    name: "input"
+    description: <<END
+The default value to produce when `output` is not fed.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A placeholder tensor that defaults to `input` if it is not fed.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of elements in the tensor.
+END
+  }
+  attr {
+    name: "shape"
+    description: <<END
+The (possibly partial) shape of the tensor.
+END
+  }
+  summary: "A placeholder op that passes through `input` when its output is not fed."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Polygamma.pbtxt b/tensorflow/core/api_def/base_api/api_def_Polygamma.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..10bf370f5493cd7e0848adfefb20c861cab076cf
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Polygamma.pbtxt
@@ -0,0 +1,12 @@
+op {
+  graph_op_name: "Polygamma"
+  summary: "Compute the polygamma function \\\\(\\psi^{(n)}(x)\\\\)."
+  description: <<END
+The polygamma function is defined as:
+
+
+\\(\psi^{(n)}(x) = \frac{d^n}{dx^n} \psi(x)\\)
+
+where \\(\psi(x)\\) is the digamma function.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_PopulationCount.pbtxt b/tensorflow/core/api_def/base_api/api_def_PopulationCount.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..97b106cd3586567902bc5b71d7b9cf9d143a12f8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_PopulationCount.pbtxt
@@ -0,0 +1,12 @@
+op {
+  graph_op_name: "PopulationCount"
+  summary: "Computes element-wise population count (a.k.a. popcount, bitsum, bitcount)."
+  description: <<END
+For each entry in `x`, calculates the number of `1` (on) bits in the binary
+representation of that entry.
+
+**NOTE**: It is more efficient to first `tf.bitcast` your tensors into
+`int32` or `int64` and perform the bitcount on the result, than to feed in
+8- or 16-bit inputs and then aggregate the resulting counts.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Pow.pbtxt b/tensorflow/core/api_def/base_api/api_def_Pow.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8ace5f3100ae0b448b80548908ab304878322f75
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Pow.pbtxt
@@ -0,0 +1,14 @@
+op {
+  graph_op_name: "Pow"
+  summary: "Computes the power of one value to another."
+  description: <<END
+Given a tensor `x` and a tensor `y`, this operation computes \\(x^y\\) for
+corresponding elements in `x` and `y`. For example:
+
+```
+# tensor 'x' is [[2, 2]], [3, 3]]
+# tensor 'y' is [[8, 16], [2, 3]]
+tf.pow(x, y) ==> [[256, 65536], [9, 27]]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_PrefetchDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_PrefetchDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e158eedc6f0ef11de3c8979d65dd69d8bece1eb4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_PrefetchDataset.pbtxt
@@ -0,0 +1,11 @@
+op {
+  graph_op_name: "PrefetchDataset"
+  in_arg {
+    name: "buffer_size"
+    description: <<END
+The maximum number of elements to buffer in an iterator over
+this dataset.
+END
+  }
+  summary: "Creates a dataset that asynchronously prefetches elements from `input_dataset`."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_PreventGradient.pbtxt b/tensorflow/core/api_def/base_api/api_def_PreventGradient.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6332192fb74fb827aaca475a8bb156e95fd8991f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_PreventGradient.pbtxt
@@ -0,0 +1,32 @@
+op {
+  graph_op_name: "PreventGradient"
+  in_arg {
+    name: "input"
+    description: <<END
+any tensor.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+the same input tensor.
+END
+  }
+  attr {
+    name: "message"
+    description: <<END
+Will be printed in the error when anyone tries to differentiate
+this operation.
+END
+  }
+  summary: "An identity op that triggers an error if a gradient is requested."
+  description: <<END
+When executed in a graph, this op outputs its input tensor as-is.
+
+When building ops to compute gradients, the TensorFlow gradient system
+will return an error when trying to lookup the gradient of this op,
+because no gradient must ever be registered for this function.  This
+op exists to prevent subtle bugs from silently returning unimplemented
+gradients in some corner cases.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Print.pbtxt b/tensorflow/core/api_def/base_api/api_def_Print.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..effbde1623efc78351c043eceabc261a8c325f88
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Print.pbtxt
@@ -0,0 +1,43 @@
+op {
+  graph_op_name: "Print"
+  in_arg {
+    name: "input"
+    description: <<END
+The tensor passed to `output`
+END
+  }
+  in_arg {
+    name: "data"
+    description: <<END
+A list of tensors to print out when op is evaluated.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+= The unmodified `input` tensor
+END
+  }
+  attr {
+    name: "message"
+    description: <<END
+A string, prefix of the error message.
+END
+  }
+  attr {
+    name: "first_n"
+    description: <<END
+Only log `first_n` number of times. -1 disables logging.
+END
+  }
+  attr {
+    name: "summarize"
+    description: <<END
+Only print this many entries of each tensor.
+END
+  }
+  summary: "Prints a list of tensors."
+  description: <<END
+Passes `input` through to `output` and prints `data` when evaluating.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_PriorityQueue.pbtxt b/tensorflow/core/api_def/base_api/api_def_PriorityQueue.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6cbcef11f8e851a84267fd014eb587725c8938f7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_PriorityQueue.pbtxt
@@ -0,0 +1,54 @@
+op {
+  graph_op_name: "PriorityQueue"
+  visibility: SKIP
+  out_arg {
+    name: "handle"
+    description: <<END
+The handle to the queue.
+END
+  }
+  attr {
+    name: "component_types"
+    description: <<END
+The type of each component in a value.
+END
+  }
+  attr {
+    name: "shapes"
+    description: <<END
+The shape of each component in a value. The length of this attr must
+be either 0 or the same as the length of component_types. If the length of
+this attr is 0, the shapes of queue elements are not constrained, and
+only one element may be dequeued at a time.
+END
+  }
+  attr {
+    name: "capacity"
+    description: <<END
+The upper bound on the number of elements in this queue.
+Negative numbers mean no limit.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this queue is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this queue will be shared under the given name
+across multiple sessions.
+END
+  }
+  summary: "A queue that produces elements sorted by the first component value."
+  description: <<END
+Note that the PriorityQueue requires the first component of any element
+to be a scalar int64, in addition to the other elements declared by
+component_types.  Therefore calls to Enqueue and EnqueueMany (resp. Dequeue
+and DequeueMany) on a PriorityQueue will all require (resp. output) one extra
+entry in their input (resp. output) lists.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_PriorityQueueV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_PriorityQueueV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f0c1499e3936a4c0ead61f8a08bb43e0f558d7c7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_PriorityQueueV2.pbtxt
@@ -0,0 +1,56 @@
+op {
+  graph_op_name: "PriorityQueueV2"
+  endpoint {
+    name: "PriorityQueue"
+  }
+  out_arg {
+    name: "handle"
+    description: <<END
+The handle to the queue.
+END
+  }
+  attr {
+    name: "component_types"
+    description: <<END
+The type of each component in a value.
+END
+  }
+  attr {
+    name: "shapes"
+    description: <<END
+The shape of each component in a value. The length of this attr must
+be either 0 or the same as the length of component_types. If the length of
+this attr is 0, the shapes of queue elements are not constrained, and
+only one element may be dequeued at a time.
+END
+  }
+  attr {
+    name: "capacity"
+    description: <<END
+The upper bound on the number of elements in this queue.
+Negative numbers mean no limit.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this queue is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this queue will be shared under the given name
+across multiple sessions.
+END
+  }
+  summary: "A queue that produces elements sorted by the first component value."
+  description: <<END
+Note that the PriorityQueue requires the first component of any element
+to be a scalar int64, in addition to the other elements declared by
+component_types.  Therefore calls to Enqueue and EnqueueMany (resp. Dequeue
+and DequeueMany) on a PriorityQueue will all require (resp. output) one extra
+entry in their input (resp. output) lists.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Prod.pbtxt b/tensorflow/core/api_def/base_api/api_def_Prod.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..02b6e425f8ae50bdde4637210484a4736088d157
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Prod.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "Prod"
+  endpoint {
+    name: "Prod"
+  }
+  endpoint {
+    name: "ReduceProd"
+  }
+  in_arg {
+    name: "input"
+    description: <<END
+The tensor to reduce.
+END
+  }
+  in_arg {
+    name: "reduction_indices"
+    rename_to: "axis"
+    description: <<END
+The dimensions to reduce. Must be in the range
+`[-rank(input), rank(input))`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The reduced tensor.
+END
+  }
+  attr {
+    name: "keep_dims"
+    description: <<END
+If true, retain reduced dimensions with length 1.
+END
+  }
+  summary: "Computes the product of elements across dimensions of a tensor."
+  description: <<END
+Reduces `input` along the dimensions given in `reduction_indices`. Unless
+`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+`reduction_indices`. If `keep_dims` is true, the reduced dimensions are
+retained with length 1.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_PyFunc.pbtxt b/tensorflow/core/api_def/base_api/api_def_PyFunc.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4b8bcf5e1210e0302102fb5baacfc769ff07d550
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_PyFunc.pbtxt
@@ -0,0 +1,40 @@
+op {
+  graph_op_name: "PyFunc"
+  visibility: SKIP
+  in_arg {
+    name: "input"
+    description: <<END
+List of Tensors that will provide input to the Op.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The outputs from the Op.
+END
+  }
+  attr {
+    name: "token"
+    description: <<END
+A token representing a registered python function in this address space.
+END
+  }
+  attr {
+    name: "Tin"
+    description: <<END
+Data types of the inputs to the op.
+END
+  }
+  attr {
+    name: "Tout"
+    description: <<END
+Data types of the outputs from the op.
+The length of the list specifies the number of outputs.
+END
+  }
+  summary: "Invokes a python function to compute func(input)->output."
+  description: <<END
+This operation is considered stateful. For a stateless version, see
+PyFuncStateless.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_PyFuncStateless.pbtxt b/tensorflow/core/api_def/base_api/api_def_PyFuncStateless.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..12962928621636e0c6b9bac9f38292d7f34ac519
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_PyFuncStateless.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "PyFuncStateless"
+  visibility: SKIP
+  summary: "A stateless version of PyFunc."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Q.pbtxt b/tensorflow/core/api_def/base_api/api_def_Q.pbtxt
deleted file mode 100644
index 4af60a184110de3da2a0a1eb79b3fc912f9d940d..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_Q.pbtxt
+++ /dev/null
@@ -1,609 +0,0 @@
-op {
-  graph_op_name: "Qr"
-  endpoint {
-    name: "Qr"
-  }
-  summary: "Computes the QR decompositions of one or more matrices."
-  description: <<END
-Computes the QR decomposition of each inner matrix in `tensor` such that
-`tensor[..., :, :] = q[..., :, :] * r[..., :,:])`
-
-```python
-# a is a tensor.
-# q is a tensor of orthonormal matrices.
-# r is a tensor of upper triangular matrices.
-q, r = qr(a)
-q_full, r_full = qr(a, full_matrices=True)
-```
-END
-}
-op {
-  graph_op_name: "QuantizeAndDequantize"
-  endpoint {
-    name: "QuantizeAndDequantize"
-  }
-  summary: "Use QuantizeAndDequantizeV2 instead."
-}
-op {
-  graph_op_name: "QuantizeAndDequantizeV2"
-  endpoint {
-    name: "QuantizeAndDequantizeV2"
-  }
-  summary: "Quantizes then dequantizes a tensor."
-  description: <<END
-This op simulates the precision loss from the quantized forward pass by:
-1. Quantizing the tensor to fixed point numbers, which should match the target
-   quantization method when it is used in inference.
-2. Dequantizing it back to floating point numbers for the following ops, most
-   likely matmul.
-
-There are different ways to quantize. This version does not use the full range
-of the output type, choosing to elide the lowest possible value for symmetry
-(e.g., output range is -127 to 127, not -128 to 127 for signed 8 bit
-quantization), so that 0.0 maps to 0.
-
-To perform this op, we first find the range of values in our tensor. The range
-we use is always centered on 0, so we find m such that
-
-1. m = max(abs(input_min), abs(input_max)) if range_given is true,
-2. m = max(abs(min_elem(input)), abs(max_elem(input))) otherwise.
-
-Our input tensor range is then [-m, m].
-
-Next, we choose our fixed-point quantization buckets, [min_fixed, max_fixed].
-If signed_input is true, this is
-
-  [min_fixed, max_fixed ] =
-      [-(1 << (num_bits - 1) - 1), (1 << (num_bits - 1)) - 1].
-
-Otherwise, if signed_input is false, the fixed-point range is
-
-  [min_fixed, max_fixed] = [0, (1 << num_bits) - 1].
-
-From this we compute our scaling factor, s:
-
-  s = (max_fixed - min_fixed) / (2 * m).
-
-Now we can quantize and dequantize the elements of our tensor.  An element e
-is transformed into e':
-
-  e' = (e * s).round_to_nearest() / s.
-
-Note that we have a different number of buckets in the signed vs. unsigned
-cases.  For example, if num_bits == 8, we get 254 buckets in the signed case
-vs. 255 in the unsigned case.
-
-For example, suppose num_bits = 8 and m = 1.  Then
-
-  [min_fixed, max_fixed] = [-127, 127], and
-  s = (127 + 127) / 2 = 127.
-
-Given the vector {-1, -0.5, 0, 0.3}, this is quantized to
-{-127, -63, 0, 38}, and dequantized to {-1, -63.0/127, 0, 38.0/127}.
-END
-}
-op {
-  graph_op_name: "QuantizeAndDequantizeV3"
-  endpoint {
-    name: "QuantizeAndDequantizeV3"
-  }
-  summary: "Quantizes then dequantizes a tensor."
-  description: <<END
-This is almost identical to QuantizeAndDequantizeV2, except that num_bits is a
-tensor, so its value can change during training.
-END
-}
-op {
-  graph_op_name: "QuantizeDownAndShrinkRange"
-  endpoint {
-    name: "QuantizeDownAndShrinkRange"
-  }
-  summary: "Convert the quantized \'input\' tensor into a lower-precision \'output\', using the"
-  description: <<END
-actual distribution of the values to maximize the usage of the lower bit depth
-and adjusting the output min and max ranges accordingly.
-
-[input_min, input_max] are scalar floats that specify the range for the float
-interpretation of the 'input' data. For example, if input_min is -1.0f and
-input_max is 1.0f, and we are dealing with quint16 quantized data, then a 0
-value in the 16-bit data should be interpreted as -1.0f, and a 65535 means 1.0f.
-
-This operator tries to squeeze as much precision as possible into an output with
-a lower bit depth by calculating the actual min and max values found in the
-data. For example, maybe that quint16 input has no values lower than 16,384 and
-none higher than 49,152. That means only half the range is actually needed, all
-the float interpretations are between -0.5f and 0.5f, so if we want to compress
-the data into a quint8 output, we can use that range rather than the theoretical
--1.0f to 1.0f that is suggested by the input min and max.
-
-In practice, this is most useful for taking output from operations like
-QuantizedMatMul that can produce higher bit-depth outputs than their inputs and
-may have large potential output ranges, but in practice have a distribution of
-input values that only uses a small fraction of the possible range. By feeding
-that output into this operator, we can reduce it from 32 bits down to 8 with
-minimal loss of accuracy.
-END
-}
-op {
-  graph_op_name: "QuantizeV2"
-  endpoint {
-    name: "QuantizeV2"
-  }
-  summary: "Quantize the \'input\' tensor of type float to \'output\' tensor of type \'T\'."
-  description: <<END
-[min_range, max_range] are scalar floats that specify the range for
-the 'input' data. The 'mode' attribute controls exactly which calculations are
-used to convert the float values to their quantized equivalents.
-
-In 'MIN_COMBINED' mode, each value of the tensor will undergo the following:
-
-```
-out[i] = (in[i] - min_range) * range(T) / (max_range - min_range)
-if T == qint8, out[i] -= (range(T) + 1) / 2.0
-```
-here `range(T) = numeric_limits<T>::max() - numeric_limits<T>::min()`
-
-*MIN_COMBINED Mode Example*
-
-Assume the input is type float and has a possible range of [0.0, 6.0] and the
-output type is quint8 ([0, 255]). The min_range and max_range values should be
-specified as 0.0 and 6.0. Quantizing from float to quint8 will multiply each
-value of the input by 255/6 and cast to quint8.
-
-If the output type was qint8 ([-128, 127]), the operation will additionally
-subtract each value by 128 prior to casting, so that the range of values aligns
-with the range of qint8.
-
-If the mode is 'MIN_FIRST', then this approach is used:
-
-```
-number_of_steps = 1 << (# of bits in T)
-range_adjust = number_of_steps / (number_of_steps - 1)
-range = (range_max - range_min) * range_adjust
-range_scale = number_of_steps / range
-quantized = round(input * range_scale) - round(range_min * range_scale) +
-  numeric_limits<T>::min()
-quantized = max(quantized, numeric_limits<T>::min())
-quantized = min(quantized, numeric_limits<T>::max())
-```
-
-The biggest difference between this and MIN_COMBINED is that the minimum range
-is rounded first, before it's subtracted from the rounded value. With
-MIN_COMBINED, a small bias is introduced where repeated iterations of quantizing
-and dequantizing will introduce a larger and larger error.
-
-*SCALED mode Example*
-
-`SCALED` mode matches the quantization approach used in
-`QuantizeAndDequantize{V2|V3}`.
-
-If the mode is `SCALED`, we do not use the full range of the output type,
-choosing to elide the lowest possible value for symmetry (e.g., output range is
--127 to 127, not -128 to 127 for signed 8 bit quantization), so that 0.0 maps to
-0.
-
-We first find the range of values in our tensor. The
-range we use is always centered on 0, so we find m such that
-```c++
-  m = max(abs(input_min), abs(input_max))
-```
-
-Our input tensor range is then `[-m, m]`.
-
-Next, we choose our fixed-point quantization buckets, `[min_fixed, max_fixed]`.
-If T is signed, this is
-```
-  num_bits = sizeof(T) * 8
-  [min_fixed, max_fixed] =
-      [-(1 << (num_bits - 1) - 1), (1 << (num_bits - 1)) - 1]
-```
-
-Otherwise, if T is unsigned, the fixed-point range is
-```
-  [min_fixed, max_fixed] = [0, (1 << num_bits) - 1]
-```
-
-From this we compute our scaling factor, s:
-```c++
-  s = (max_fixed - min_fixed) / (2 * m)
-```
-
-Now we can quantize the elements of our tensor:
-```c++
-result = (input * s).round_to_nearest()
-```
-
-One thing to watch out for is that the operator may choose to adjust the
-requested minimum and maximum values slightly during the quantization process,
-so you should always use the output ports as the range for further calculations.
-For example, if the requested minimum and maximum values are close to equal,
-they will be separated by a small epsilon value to prevent ill-formed quantized
-buffers from being created. Otherwise, you can end up with buffers where all the
-quantized values map to the same float value, which causes problems for
-operations that have to perform further calculations on them.
-END
-}
-op {
-  graph_op_name: "QuantizedAdd"
-  endpoint {
-    name: "QuantizedAdd"
-  }
-  summary: "Returns x + y element-wise, working on quantized buffers."
-}
-op {
-  graph_op_name: "QuantizedAvgPool"
-  endpoint {
-    name: "QuantizedAvgPool"
-  }
-  summary: "Produces the average pool of the input tensor for quantized types."
-}
-op {
-  graph_op_name: "QuantizedBatchNormWithGlobalNormalization"
-  endpoint {
-    name: "QuantizedBatchNormWithGlobalNormalization"
-  }
-  summary: "Quantized Batch normalization."
-  description: <<END
-This op is deprecated and will be removed in the future. Prefer
-`tf.nn.batch_normalization`.
-END
-}
-op {
-  graph_op_name: "QuantizedBiasAdd"
-  endpoint {
-    name: "QuantizedBiasAdd"
-  }
-  summary: "Adds Tensor \'bias\' to Tensor \'input\' for Quantized types."
-  description: <<END
-Broadcasts the values of bias on dimensions 0..N-2 of 'input'.
-END
-}
-op {
-  graph_op_name: "QuantizedConcat"
-  endpoint {
-    name: "QuantizedConcat"
-  }
-  summary: "Concatenates quantized tensors along one dimension."
-}
-op {
-  graph_op_name: "QuantizedConv2D"
-  endpoint {
-    name: "QuantizedConv2D"
-  }
-  summary: "Computes a 2D convolution given quantized 4D input and filter tensors."
-  description: <<END
-The inputs are quantized tensors where the lowest value represents the real
-number of the associated minimum, and the highest represents the maximum.
-This means that you can only interpret the quantized output in the same way, by
-taking the returned minimum and maximum values into account.
-END
-}
-op {
-  graph_op_name: "QuantizedInstanceNorm"
-  endpoint {
-    name: "QuantizedInstanceNorm"
-  }
-  summary: "Quantized Instance normalization."
-}
-op {
-  graph_op_name: "QuantizedMatMul"
-  endpoint {
-    name: "QuantizedMatMul"
-  }
-  summary: "Perform a quantized matrix multiplication of  `a` by the matrix `b`."
-  description: <<END
-The inputs must be two-dimensional matrices and the inner dimension of
-`a` (after being transposed if `transpose_a` is non-zero) must match the
-outer dimension of `b` (after being transposed if `transposed_b` is
-non-zero).
-END
-}
-op {
-  graph_op_name: "QuantizedMaxPool"
-  endpoint {
-    name: "QuantizedMaxPool"
-  }
-  summary: "Produces the max pool of the input tensor for quantized types."
-}
-op {
-  graph_op_name: "QuantizedMul"
-  endpoint {
-    name: "QuantizedMul"
-  }
-  summary: "Returns x * y element-wise, working on quantized buffers."
-}
-op {
-  graph_op_name: "QuantizedRelu"
-  endpoint {
-    name: "QuantizedRelu"
-  }
-  summary: "Computes Quantized Rectified Linear: `max(features, 0)`"
-}
-op {
-  graph_op_name: "QuantizedRelu6"
-  endpoint {
-    name: "QuantizedRelu6"
-  }
-  summary: "Computes Quantized Rectified Linear 6: `min(max(features, 0), 6)`"
-}
-op {
-  graph_op_name: "QuantizedReluX"
-  endpoint {
-    name: "QuantizedReluX"
-  }
-  summary: "Computes Quantized Rectified Linear X: `min(max(features, 0), max_value)`"
-}
-op {
-  graph_op_name: "QuantizedReshape"
-  endpoint {
-    name: "QuantizedReshape"
-  }
-  summary: "Reshapes a quantized tensor as per the Reshape op."
-  description: <<END
-```
-END
-}
-op {
-  graph_op_name: "QuantizedResizeBilinear"
-  endpoint {
-    name: "QuantizedResizeBilinear"
-  }
-  summary: "Resize quantized `images` to `size` using quantized bilinear interpolation."
-  description: <<END
-Input images and output images must be quantized types.
-END
-}
-op {
-  graph_op_name: "QueueClose"
-  endpoint {
-    name: "QueueClose"
-  }
-  summary: "Closes the given queue."
-  description: <<END
-This operation signals that no more elements will be enqueued in the
-given queue. Subsequent Enqueue(Many) operations will fail.
-Subsequent Dequeue(Many) operations will continue to succeed if
-sufficient elements remain in the queue. Subsequent Dequeue(Many)
-operations that would block will fail immediately.
-END
-}
-op {
-  graph_op_name: "QueueCloseV2"
-  endpoint {
-    name: "QueueCloseV2"
-  }
-  summary: "Closes the given queue."
-  description: <<END
-This operation signals that no more elements will be enqueued in the
-given queue. Subsequent Enqueue(Many) operations will fail.
-Subsequent Dequeue(Many) operations will continue to succeed if
-sufficient elements remain in the queue. Subsequent Dequeue(Many)
-operations that would block will fail immediately.
-END
-}
-op {
-  graph_op_name: "QueueDequeue"
-  endpoint {
-    name: "QueueDequeue"
-  }
-  summary: "Dequeues a tuple of one or more tensors from the given queue."
-  description: <<END
-This operation has k outputs, where k is the number of components
-in the tuples stored in the given queue, and output i is the ith
-component of the dequeued tuple.
-
-N.B. If the queue is empty, this operation will block until an element
-has been dequeued (or 'timeout_ms' elapses, if specified).
-END
-}
-op {
-  graph_op_name: "QueueDequeueMany"
-  endpoint {
-    name: "QueueDequeueMany"
-  }
-  summary: "Dequeues `n` tuples of one or more tensors from the given queue."
-  description: <<END
-If the queue is closed and there are fewer than `n` elements, then an
-OutOfRange error is returned.
-
-This operation concatenates queue-element component tensors along the
-0th dimension to make a single component tensor.  All of the components
-in the dequeued tuple will have size `n` in the 0th dimension.
-
-This operation has `k` outputs, where `k` is the number of components in
-the tuples stored in the given queue, and output `i` is the ith
-component of the dequeued tuple.
-
-N.B. If the queue is empty, this operation will block until `n` elements
-have been dequeued (or 'timeout_ms' elapses, if specified).
-END
-}
-op {
-  graph_op_name: "QueueDequeueManyV2"
-  endpoint {
-    name: "QueueDequeueManyV2"
-  }
-  summary: "Dequeues `n` tuples of one or more tensors from the given queue."
-  description: <<END
-If the queue is closed and there are fewer than `n` elements, then an
-OutOfRange error is returned.
-
-This operation concatenates queue-element component tensors along the
-0th dimension to make a single component tensor.  All of the components
-in the dequeued tuple will have size `n` in the 0th dimension.
-
-This operation has `k` outputs, where `k` is the number of components in
-the tuples stored in the given queue, and output `i` is the ith
-component of the dequeued tuple.
-
-N.B. If the queue is empty, this operation will block until `n` elements
-have been dequeued (or 'timeout_ms' elapses, if specified).
-END
-}
-op {
-  graph_op_name: "QueueDequeueUpTo"
-  endpoint {
-    name: "QueueDequeueUpTo"
-  }
-  summary: "Dequeues `n` tuples of one or more tensors from the given queue."
-  description: <<END
-This operation is not supported by all queues.  If a queue does not support
-DequeueUpTo, then an Unimplemented error is returned.
-
-If the queue is closed and there are more than 0 but less than `n`
-elements remaining, then instead of returning an OutOfRange error like
-QueueDequeueMany, less than `n` elements are returned immediately.  If
-the queue is closed and there are 0 elements left in the queue, then
-an OutOfRange error is returned just like in QueueDequeueMany.
-Otherwise the behavior is identical to QueueDequeueMany:
-
-This operation concatenates queue-element component tensors along the
-0th dimension to make a single component tensor.  All of the components
-in the dequeued tuple will have size `n` in the 0th dimension.
-
-This operation has k outputs, where `k` is the number of components in
-the tuples stored in the given queue, and output `i` is the ith
-component of the dequeued tuple.
-END
-}
-op {
-  graph_op_name: "QueueDequeueUpToV2"
-  endpoint {
-    name: "QueueDequeueUpToV2"
-  }
-  summary: "Dequeues `n` tuples of one or more tensors from the given queue."
-  description: <<END
-This operation is not supported by all queues.  If a queue does not support
-DequeueUpTo, then an Unimplemented error is returned.
-
-If the queue is closed and there are more than 0 but less than `n`
-elements remaining, then instead of returning an OutOfRange error like
-QueueDequeueMany, less than `n` elements are returned immediately.  If
-the queue is closed and there are 0 elements left in the queue, then
-an OutOfRange error is returned just like in QueueDequeueMany.
-Otherwise the behavior is identical to QueueDequeueMany:
-
-This operation concatenates queue-element component tensors along the
-0th dimension to make a single component tensor.  All of the components
-in the dequeued tuple will have size n in the 0th dimension.
-
-This operation has `k` outputs, where `k` is the number of components in
-the tuples stored in the given queue, and output `i` is the ith
-component of the dequeued tuple.
-END
-}
-op {
-  graph_op_name: "QueueDequeueV2"
-  endpoint {
-    name: "QueueDequeueV2"
-  }
-  summary: "Dequeues a tuple of one or more tensors from the given queue."
-  description: <<END
-This operation has k outputs, where k is the number of components
-in the tuples stored in the given queue, and output i is the ith
-component of the dequeued tuple.
-
-N.B. If the queue is empty, this operation will block until an element
-has been dequeued (or 'timeout_ms' elapses, if specified).
-END
-}
-op {
-  graph_op_name: "QueueEnqueue"
-  endpoint {
-    name: "QueueEnqueue"
-  }
-  summary: "Enqueues a tuple of one or more tensors in the given queue."
-  description: <<END
-The components input has k elements, which correspond to the components of
-tuples stored in the given queue.
-
-N.B. If the queue is full, this operation will block until the given
-element has been enqueued (or 'timeout_ms' elapses, if specified).
-END
-}
-op {
-  graph_op_name: "QueueEnqueueMany"
-  endpoint {
-    name: "QueueEnqueueMany"
-  }
-  summary: "Enqueues zero or more tuples of one or more tensors in the given queue."
-  description: <<END
-This operation slices each component tensor along the 0th dimension to
-make multiple queue elements. All of the tuple components must have the
-same size in the 0th dimension.
-
-The components input has k elements, which correspond to the components of
-tuples stored in the given queue.
-
-N.B. If the queue is full, this operation will block until the given
-elements have been enqueued (or 'timeout_ms' elapses, if specified).
-END
-}
-op {
-  graph_op_name: "QueueEnqueueManyV2"
-  endpoint {
-    name: "QueueEnqueueManyV2"
-  }
-  summary: "Enqueues zero or more tuples of one or more tensors in the given queue."
-  description: <<END
-This operation slices each component tensor along the 0th dimension to
-make multiple queue elements. All of the tuple components must have the
-same size in the 0th dimension.
-
-The components input has k elements, which correspond to the components of
-tuples stored in the given queue.
-
-N.B. If the queue is full, this operation will block until the given
-elements have been enqueued (or 'timeout_ms' elapses, if specified).
-END
-}
-op {
-  graph_op_name: "QueueEnqueueV2"
-  endpoint {
-    name: "QueueEnqueueV2"
-  }
-  summary: "Enqueues a tuple of one or more tensors in the given queue."
-  description: <<END
-The components input has k elements, which correspond to the components of
-tuples stored in the given queue.
-
-N.B. If the queue is full, this operation will block until the given
-element has been enqueued (or 'timeout_ms' elapses, if specified).
-END
-}
-op {
-  graph_op_name: "QueueIsClosed"
-  endpoint {
-    name: "QueueIsClosed"
-  }
-  summary: "Returns true if queue is closed."
-  description: <<END
-This operation returns true if the queue is closed and false if the queue
-is open.
-END
-}
-op {
-  graph_op_name: "QueueIsClosedV2"
-  endpoint {
-    name: "QueueIsClosedV2"
-  }
-  summary: "Returns true if queue is closed."
-  description: <<END
-This operation returns true if the queue is closed and false if the queue
-is open.
-END
-}
-op {
-  graph_op_name: "QueueSize"
-  endpoint {
-    name: "QueueSize"
-  }
-  summary: "Computes the number of elements in the given queue."
-}
-op {
-  graph_op_name: "QueueSizeV2"
-  endpoint {
-    name: "QueueSizeV2"
-  }
-  summary: "Computes the number of elements in the given queue."
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_Qr.pbtxt b/tensorflow/core/api_def/base_api/api_def_Qr.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ac8f7597aae9e9ba04cfbfa65ad9417f816fa153
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Qr.pbtxt
@@ -0,0 +1,45 @@
+op {
+  graph_op_name: "Qr"
+  in_arg {
+    name: "input"
+    description: <<END
+A tensor of shape `[..., M, N]` whose inner-most 2 dimensions
+form matrices of size `[M, N]`. Let `P` be the minimum of `M` and `N`.
+END
+  }
+  out_arg {
+    name: "q"
+    description: <<END
+Orthonormal basis for range of `a`. If `full_matrices` is `False` then
+shape is `[..., M, P]`; if `full_matrices` is `True` then shape is
+`[..., M, M]`.
+END
+  }
+  out_arg {
+    name: "r"
+    description: <<END
+Triangular factor. If `full_matrices` is `False` then shape is
+`[..., P, N]`. If `full_matrices` is `True` then shape is `[..., M, N]`.
+END
+  }
+  attr {
+    name: "full_matrices"
+    description: <<END
+If true, compute full-sized `q` and `r`. If false
+(the default), compute only the leading `P` columns of `q`.
+END
+  }
+  summary: "Computes the QR decompositions of one or more matrices."
+  description: <<END
+Computes the QR decomposition of each inner matrix in `tensor` such that
+`tensor[..., :, :] = q[..., :, :] * r[..., :,:])`
+
+```python
+# a is a tensor.
+# q is a tensor of orthonormal matrices.
+# r is a tensor of upper triangular matrices.
+q, r = qr(a)
+q_full, r_full = qr(a, full_matrices=True)
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizeAndDequantize.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizeAndDequantize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8d84144d336f2adf5e05b7519325dd8ae6c9ec85
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizeAndDequantize.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "QuantizeAndDequantize"
+  summary: "Use QuantizeAndDequantizeV2 instead."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizeAndDequantizeV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizeAndDequantizeV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1fc9c9034a1f56ea319f4d3e6df0ded47fda4200
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizeAndDequantizeV2.pbtxt
@@ -0,0 +1,93 @@
+op {
+  graph_op_name: "QuantizeAndDequantizeV2"
+  in_arg {
+    name: "input"
+    description: <<END
+Tensor to quantize and then dequantize.
+END
+  }
+  in_arg {
+    name: "input_min"
+    description: <<END
+If range_given, this is the min of the range, otherwise this input
+will be ignored.
+END
+  }
+  in_arg {
+    name: "input_max"
+    description: <<END
+If range_given, this is the max of the range, otherwise this input
+will be ignored.
+END
+  }
+  attr {
+    name: "signed_input"
+    description: <<END
+If the quantization is signed or unsigned.
+END
+  }
+  attr {
+    name: "num_bits"
+    description: <<END
+The bitwidth of the quantization.
+END
+  }
+  attr {
+    name: "range_given"
+    description: <<END
+If the range is given or should be computed from the tensor.
+END
+  }
+  summary: "Quantizes then dequantizes a tensor."
+  description: <<END
+This op simulates the precision loss from the quantized forward pass by:
+1. Quantizing the tensor to fixed point numbers, which should match the target
+   quantization method when it is used in inference.
+2. Dequantizing it back to floating point numbers for the following ops, most
+   likely matmul.
+
+There are different ways to quantize. This version does not use the full range
+of the output type, choosing to elide the lowest possible value for symmetry
+(e.g., output range is -127 to 127, not -128 to 127 for signed 8 bit
+quantization), so that 0.0 maps to 0.
+
+To perform this op, we first find the range of values in our tensor. The range
+we use is always centered on 0, so we find m such that
+
+1. m = max(abs(input_min), abs(input_max)) if range_given is true,
+2. m = max(abs(min_elem(input)), abs(max_elem(input))) otherwise.
+
+Our input tensor range is then [-m, m].
+
+Next, we choose our fixed-point quantization buckets, [min_fixed, max_fixed].
+If signed_input is true, this is
+
+  [min_fixed, max_fixed ] =
+      [-(1 << (num_bits - 1) - 1), (1 << (num_bits - 1)) - 1].
+
+Otherwise, if signed_input is false, the fixed-point range is
+
+  [min_fixed, max_fixed] = [0, (1 << num_bits) - 1].
+
+From this we compute our scaling factor, s:
+
+  s = (max_fixed - min_fixed) / (2 * m).
+
+Now we can quantize and dequantize the elements of our tensor.  An element e
+is transformed into e':
+
+  e' = (e * s).round_to_nearest() / s.
+
+Note that we have a different number of buckets in the signed vs. unsigned
+cases.  For example, if num_bits == 8, we get 254 buckets in the signed case
+vs. 255 in the unsigned case.
+
+For example, suppose num_bits = 8 and m = 1.  Then
+
+  [min_fixed, max_fixed] = [-127, 127], and
+  s = (127 + 127) / 2 = 127.
+
+Given the vector {-1, -0.5, 0, 0.3}, this is quantized to
+{-127, -63, 0, 38}, and dequantized to {-1, -63.0/127, 0, 38.0/127}.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizeAndDequantizeV3.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizeAndDequantizeV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..57128a842a7c016e649ef3da5afc6d282ec6550a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizeAndDequantizeV3.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "QuantizeAndDequantizeV3"
+  summary: "Quantizes then dequantizes a tensor."
+  description: <<END
+This is almost identical to QuantizeAndDequantizeV2, except that num_bits is a
+tensor, so its value can change during training.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizeDownAndShrinkRange.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizeDownAndShrinkRange.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..af7729e2384d3c1872edb7c199f7c60d6bde27b7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizeDownAndShrinkRange.pbtxt
@@ -0,0 +1,64 @@
+op {
+  graph_op_name: "QuantizeDownAndShrinkRange"
+  in_arg {
+    name: "input_min"
+    description: <<END
+The float value that the minimum quantized input value represents.
+END
+  }
+  in_arg {
+    name: "input_max"
+    description: <<END
+The float value that the maximum quantized input value represents.
+END
+  }
+  out_arg {
+    name: "output_min"
+    description: <<END
+The float value that the minimum quantized output value represents.
+END
+  }
+  out_arg {
+    name: "output_max"
+    description: <<END
+The float value that the maximum quantized output value represents.
+END
+  }
+  attr {
+    name: "Tinput"
+    description: <<END
+The type of the input.
+END
+  }
+  attr {
+    name: "out_type"
+    description: <<END
+The type of the output. Should be a lower bit depth than Tinput.
+END
+  }
+  summary: "Convert the quantized \'input\' tensor into a lower-precision \'output\', using the"
+  description: <<END
+actual distribution of the values to maximize the usage of the lower bit depth
+and adjusting the output min and max ranges accordingly.
+
+[input_min, input_max] are scalar floats that specify the range for the float
+interpretation of the 'input' data. For example, if input_min is -1.0f and
+input_max is 1.0f, and we are dealing with quint16 quantized data, then a 0
+value in the 16-bit data should be interpreted as -1.0f, and a 65535 means 1.0f.
+
+This operator tries to squeeze as much precision as possible into an output with
+a lower bit depth by calculating the actual min and max values found in the
+data. For example, maybe that quint16 input has no values lower than 16,384 and
+none higher than 49,152. That means only half the range is actually needed, all
+the float interpretations are between -0.5f and 0.5f, so if we want to compress
+the data into a quint8 output, we can use that range rather than the theoretical
+-1.0f to 1.0f that is suggested by the input min and max.
+
+In practice, this is most useful for taking output from operations like
+QuantizedMatMul that can produce higher bit-depth outputs than their inputs and
+may have large potential output ranges, but in practice have a distribution of
+input values that only uses a small fraction of the possible range. By feeding
+that output into this operator, we can reduce it from 32 bits down to 8 with
+minimal loss of accuracy.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizeV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizeV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b9e75caf02b3b557e632a8137cf4780178b8ad8a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizeV2.pbtxt
@@ -0,0 +1,128 @@
+op {
+  graph_op_name: "QuantizeV2"
+  in_arg {
+    name: "min_range"
+    description: <<END
+The minimum scalar value possibly produced for the input.
+END
+  }
+  in_arg {
+    name: "max_range"
+    description: <<END
+The maximum scalar value possibly produced for the input.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The quantized data produced from the float input.
+END
+  }
+  out_arg {
+    name: "output_min"
+    description: <<END
+The actual minimum scalar value used for the output.
+END
+  }
+  out_arg {
+    name: "output_max"
+    description: <<END
+The actual maximum scalar value used for the output.
+END
+  }
+  summary: "Quantize the \'input\' tensor of type float to \'output\' tensor of type \'T\'."
+  description: <<END
+[min_range, max_range] are scalar floats that specify the range for
+the 'input' data. The 'mode' attribute controls exactly which calculations are
+used to convert the float values to their quantized equivalents.  The
+'round_mode' attribute controls which rounding tie-breaking algorithm is used
+when rounding float values to their quantized equivalents.
+
+In 'MIN_COMBINED' mode, each value of the tensor will undergo the following:
+
+```
+out[i] = (in[i] - min_range) * range(T) / (max_range - min_range)
+if T == qint8, out[i] -= (range(T) + 1) / 2.0
+```
+here `range(T) = numeric_limits<T>::max() - numeric_limits<T>::min()`
+
+*MIN_COMBINED Mode Example*
+
+Assume the input is type float and has a possible range of [0.0, 6.0] and the
+output type is quint8 ([0, 255]). The min_range and max_range values should be
+specified as 0.0 and 6.0. Quantizing from float to quint8 will multiply each
+value of the input by 255/6 and cast to quint8.
+
+If the output type was qint8 ([-128, 127]), the operation will additionally
+subtract each value by 128 prior to casting, so that the range of values aligns
+with the range of qint8.
+
+If the mode is 'MIN_FIRST', then this approach is used:
+
+```
+num_discrete_values = 1 << (# of bits in T)
+range_adjust = num_discrete_values / (num_discrete_values - 1)
+range = (range_max - range_min) * range_adjust
+range_scale = num_discrete_values / range
+quantized = round(input * range_scale) - round(range_min * range_scale) +
+  numeric_limits<T>::min()
+quantized = max(quantized, numeric_limits<T>::min())
+quantized = min(quantized, numeric_limits<T>::max())
+```
+
+The biggest difference between this and MIN_COMBINED is that the minimum range
+is rounded first, before it's subtracted from the rounded value. With
+MIN_COMBINED, a small bias is introduced where repeated iterations of quantizing
+and dequantizing will introduce a larger and larger error.
+
+*SCALED mode Example*
+
+`SCALED` mode matches the quantization approach used in
+`QuantizeAndDequantize{V2|V3}`.
+
+If the mode is `SCALED`, we do not use the full range of the output type,
+choosing to elide the lowest possible value for symmetry (e.g., output range is
+-127 to 127, not -128 to 127 for signed 8 bit quantization), so that 0.0 maps to
+0.
+
+We first find the range of values in our tensor. The
+range we use is always centered on 0, so we find m such that
+```c++
+  m = max(abs(input_min), abs(input_max))
+```
+
+Our input tensor range is then `[-m, m]`.
+
+Next, we choose our fixed-point quantization buckets, `[min_fixed, max_fixed]`.
+If T is signed, this is
+```
+  num_bits = sizeof(T) * 8
+  [min_fixed, max_fixed] =
+      [-(1 << (num_bits - 1) - 1), (1 << (num_bits - 1)) - 1]
+```
+
+Otherwise, if T is unsigned, the fixed-point range is
+```
+  [min_fixed, max_fixed] = [0, (1 << num_bits) - 1]
+```
+
+From this we compute our scaling factor, s:
+```c++
+  s = (max_fixed - min_fixed) / (2 * m)
+```
+
+Now we can quantize the elements of our tensor:
+```c++
+result = round(input * s)
+```
+
+One thing to watch out for is that the operator may choose to adjust the
+requested minimum and maximum values slightly during the quantization process,
+so you should always use the output ports as the range for further calculations.
+For example, if the requested minimum and maximum values are close to equal,
+they will be separated by a small epsilon value to prevent ill-formed quantized
+buffers from being created. Otherwise, you can end up with buffers where all the
+quantized values map to the same float value, which causes problems for
+operations that have to perform further calculations on them.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizedAdd.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizedAdd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..193bee4db915e5b12f5a316e9249e3a953019b1e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizedAdd.pbtxt
@@ -0,0 +1,43 @@
+op {
+  graph_op_name: "QuantizedAdd"
+  in_arg {
+    name: "min_x"
+    description: <<END
+The float value that the lowest quantized `x` value represents.
+END
+  }
+  in_arg {
+    name: "max_x"
+    description: <<END
+The float value that the highest quantized `x` value represents.
+END
+  }
+  in_arg {
+    name: "min_y"
+    description: <<END
+The float value that the lowest quantized `y` value represents.
+END
+  }
+  in_arg {
+    name: "max_y"
+    description: <<END
+The float value that the highest quantized `y` value represents.
+END
+  }
+  out_arg {
+    name: "min_z"
+    description: <<END
+The float value that the lowest quantized output value represents.
+END
+  }
+  out_arg {
+    name: "max_z"
+    description: <<END
+The float value that the highest quantized output value represents.
+
+*NOTE*: `QuantizedAdd` supports limited forms of broadcasting. More about
+broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+  }
+  summary: "Returns x + y element-wise, working on quantized buffers."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizedAvgPool.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizedAvgPool.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..912ab540264198963783957300e0300368cd5b5d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizedAvgPool.pbtxt
@@ -0,0 +1,54 @@
+op {
+  graph_op_name: "QuantizedAvgPool"
+  in_arg {
+    name: "input"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.
+END
+  }
+  in_arg {
+    name: "min_input"
+    description: <<END
+The float value that the lowest quantized input value represents.
+END
+  }
+  in_arg {
+    name: "max_input"
+    description: <<END
+The float value that the highest quantized input value represents.
+END
+  }
+  out_arg {
+    name: "min_output"
+    description: <<END
+The float value that the lowest quantized output value represents.
+END
+  }
+  out_arg {
+    name: "max_output"
+    description: <<END
+The float value that the highest quantized output value represents.
+END
+  }
+  attr {
+    name: "ksize"
+    description: <<END
+The size of the window for each dimension of the input tensor.
+The length must be 4 to match the number of dimensions of the input.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the input
+tensor.  The length must be 4 to match the number of dimensions of the input.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  summary: "Produces the average pool of the input tensor for quantized types."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizedBatchNormWithGlobalNormalization.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizedBatchNormWithGlobalNormalization.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..27990db1d07f901e9503d868d7f2b8cabdd5282c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizedBatchNormWithGlobalNormalization.pbtxt
@@ -0,0 +1,118 @@
+op {
+  graph_op_name: "QuantizedBatchNormWithGlobalNormalization"
+  in_arg {
+    name: "t"
+    description: <<END
+A 4D input Tensor.
+END
+  }
+  in_arg {
+    name: "t_min"
+    description: <<END
+The value represented by the lowest quantized input.
+END
+  }
+  in_arg {
+    name: "t_max"
+    description: <<END
+The value represented by the highest quantized input.
+END
+  }
+  in_arg {
+    name: "m"
+    description: <<END
+A 1D mean Tensor with size matching the last dimension of t.
+This is the first output from tf.nn.moments,
+or a saved moving average thereof.
+END
+  }
+  in_arg {
+    name: "m_min"
+    description: <<END
+The value represented by the lowest quantized mean.
+END
+  }
+  in_arg {
+    name: "m_max"
+    description: <<END
+The value represented by the highest quantized mean.
+END
+  }
+  in_arg {
+    name: "v"
+    description: <<END
+A 1D variance Tensor with size matching the last dimension of t.
+This is the second output from tf.nn.moments,
+or a saved moving average thereof.
+END
+  }
+  in_arg {
+    name: "v_min"
+    description: <<END
+The value represented by the lowest quantized variance.
+END
+  }
+  in_arg {
+    name: "v_max"
+    description: <<END
+The value represented by the highest quantized variance.
+END
+  }
+  in_arg {
+    name: "beta"
+    description: <<END
+A 1D beta Tensor with size matching the last dimension of t.
+An offset to be added to the normalized tensor.
+END
+  }
+  in_arg {
+    name: "beta_min"
+    description: <<END
+The value represented by the lowest quantized offset.
+END
+  }
+  in_arg {
+    name: "beta_max"
+    description: <<END
+The value represented by the highest quantized offset.
+END
+  }
+  in_arg {
+    name: "gamma"
+    description: <<END
+A 1D gamma Tensor with size matching the last dimension of t.
+If "scale_after_normalization" is true, this tensor will be multiplied
+with the normalized tensor.
+END
+  }
+  in_arg {
+    name: "gamma_min"
+    description: <<END
+The value represented by the lowest quantized gamma.
+END
+  }
+  in_arg {
+    name: "gamma_max"
+    description: <<END
+The value represented by the highest quantized gamma.
+END
+  }
+  attr {
+    name: "variance_epsilon"
+    description: <<END
+A small float number to avoid dividing by 0.
+END
+  }
+  attr {
+    name: "scale_after_normalization"
+    description: <<END
+A bool indicating whether the resulted tensor
+needs to be multiplied with gamma.
+END
+  }
+  summary: "Quantized Batch normalization."
+  description: <<END
+This op is deprecated and will be removed in the future. Prefer
+`tf.nn.batch_normalization`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizedBiasAdd.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizedBiasAdd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1d714e3aa28ed47b58d44df1f77b9ad9821838d3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizedBiasAdd.pbtxt
@@ -0,0 +1,49 @@
+op {
+  graph_op_name: "QuantizedBiasAdd"
+  in_arg {
+    name: "bias"
+    description: <<END
+A 1D bias Tensor with size matching the last dimension of 'input'.
+END
+  }
+  in_arg {
+    name: "min_input"
+    description: <<END
+The float value that the lowest quantized input value represents.
+END
+  }
+  in_arg {
+    name: "max_input"
+    description: <<END
+The float value that the highest quantized input value represents.
+END
+  }
+  in_arg {
+    name: "min_bias"
+    description: <<END
+The float value that the lowest quantized bias value represents.
+END
+  }
+  in_arg {
+    name: "max_bias"
+    description: <<END
+The float value that the highest quantized bias value represents.
+END
+  }
+  out_arg {
+    name: "min_out"
+    description: <<END
+The float value that the lowest quantized output value represents.
+END
+  }
+  out_arg {
+    name: "max_out"
+    description: <<END
+The float value that the highest quantized output value represents.
+END
+  }
+  summary: "Adds Tensor \'bias\' to Tensor \'input\' for Quantized types."
+  description: <<END
+Broadcasts the values of bias on dimensions 0..N-2 of 'input'.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizedConcat.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizedConcat.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e39654fe9010836f5e8c1e8be80c677b33252fae
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizedConcat.pbtxt
@@ -0,0 +1,50 @@
+op {
+  graph_op_name: "QuantizedConcat"
+  in_arg {
+    name: "concat_dim"
+    description: <<END
+0-D.  The dimension along which to concatenate.  Must be in the
+range [0, rank(values)).
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+The `N` Tensors to concatenate. Their ranks and types must match,
+and their sizes must match in all dimensions except `concat_dim`.
+END
+  }
+  in_arg {
+    name: "input_mins"
+    description: <<END
+The minimum scalar values for each of the input tensors.
+END
+  }
+  in_arg {
+    name: "input_maxes"
+    description: <<END
+The maximum scalar values for each of the input tensors.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A `Tensor` with the concatenation of values stacked along the
+`concat_dim` dimension.  This tensor's shape matches that of `values` except
+in `concat_dim` where it has the sum of the sizes.
+END
+  }
+  out_arg {
+    name: "output_min"
+    description: <<END
+The float value that the minimum quantized output value represents.
+END
+  }
+  out_arg {
+    name: "output_max"
+    description: <<END
+The float value that the maximum quantized output value represents.
+END
+  }
+  summary: "Concatenates quantized tensors along one dimension."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizedConv2D.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizedConv2D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b19bbeab12db322064dcbf31779ce01adffadeb9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizedConv2D.pbtxt
@@ -0,0 +1,65 @@
+op {
+  graph_op_name: "QuantizedConv2D"
+  in_arg {
+    name: "filter"
+    description: <<END
+filter's input_depth dimension must match input's depth dimensions.
+END
+  }
+  in_arg {
+    name: "min_input"
+    description: <<END
+The float value that the lowest quantized input value represents.
+END
+  }
+  in_arg {
+    name: "max_input"
+    description: <<END
+The float value that the highest quantized input value represents.
+END
+  }
+  in_arg {
+    name: "min_filter"
+    description: <<END
+The float value that the lowest quantized filter value represents.
+END
+  }
+  in_arg {
+    name: "max_filter"
+    description: <<END
+The float value that the highest quantized filter value represents.
+END
+  }
+  out_arg {
+    name: "min_output"
+    description: <<END
+The float value that the lowest quantized output value represents.
+END
+  }
+  out_arg {
+    name: "max_output"
+    description: <<END
+The float value that the highest quantized output value represents.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the input
+tensor.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  summary: "Computes a 2D convolution given quantized 4D input and filter tensors."
+  description: <<END
+The inputs are quantized tensors where the lowest value represents the real
+number of the associated minimum, and the highest represents the maximum.
+This means that you can only interpret the quantized output in the same way, by
+taking the returned minimum and maximum values into account.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizedInstanceNorm.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizedInstanceNorm.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7c30870fde48782101849fcfdd02169f201bfe60
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizedInstanceNorm.pbtxt
@@ -0,0 +1,72 @@
+op {
+  graph_op_name: "QuantizedInstanceNorm"
+  in_arg {
+    name: "x"
+    description: <<END
+A 4D input Tensor.
+END
+  }
+  in_arg {
+    name: "x_min"
+    description: <<END
+The value represented by the lowest quantized input.
+END
+  }
+  in_arg {
+    name: "x_max"
+    description: <<END
+The value represented by the highest quantized input.
+END
+  }
+  out_arg {
+    name: "y"
+    description: <<END
+A 4D Tensor.
+END
+  }
+  out_arg {
+    name: "y_min"
+    description: <<END
+The value represented by the lowest quantized output.
+END
+  }
+  out_arg {
+    name: "y_max"
+    description: <<END
+The value represented by the highest quantized output.
+END
+  }
+  attr {
+    name: "output_range_given"
+    description: <<END
+If True, `given_y_min` and `given_y_min`
+and `given_y_max` are used as the output range. Otherwise,
+the implementation computes the output range.
+END
+  }
+  attr {
+    name: "given_y_min"
+    description: <<END
+Output in `y_min` if `output_range_given` is True.
+END
+  }
+  attr {
+    name: "given_y_max"
+    description: <<END
+Output in `y_max` if `output_range_given` is True.
+END
+  }
+  attr {
+    name: "variance_epsilon"
+    description: <<END
+A small float number to avoid dividing by 0.
+END
+  }
+  attr {
+    name: "min_separation"
+    description: <<END
+Minimum value of `y_max - y_min`
+END
+  }
+  summary: "Quantized Instance normalization."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizedMatMul.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizedMatMul.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d31820890084f39e746b1f7ee92c3dbc29d8f520
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizedMatMul.pbtxt
@@ -0,0 +1,77 @@
+op {
+  graph_op_name: "QuantizedMatMul"
+  in_arg {
+    name: "a"
+    description: <<END
+Must be a two-dimensional tensor.
+END
+  }
+  in_arg {
+    name: "b"
+    description: <<END
+Must be a two-dimensional tensor.
+END
+  }
+  in_arg {
+    name: "min_a"
+    description: <<END
+The float value that the lowest quantized `a` value represents.
+END
+  }
+  in_arg {
+    name: "max_a"
+    description: <<END
+The float value that the highest quantized `a` value represents.
+END
+  }
+  in_arg {
+    name: "min_b"
+    description: <<END
+The float value that the lowest quantized `b` value represents.
+END
+  }
+  in_arg {
+    name: "max_b"
+    description: <<END
+The float value that the highest quantized `b` value represents.
+END
+  }
+  out_arg {
+    name: "min_out"
+    description: <<END
+The float value that the lowest quantized output value represents.
+END
+  }
+  out_arg {
+    name: "max_out"
+    description: <<END
+The float value that the highest quantized output value represents.
+END
+  }
+  attr {
+    name: "transpose_a"
+    description: <<END
+If true, `a` is transposed before multiplication.
+END
+  }
+  attr {
+    name: "transpose_b"
+    description: <<END
+If true, `b` is transposed before multiplication.
+END
+  }
+  attr {
+    name: "Tactivation"
+    description: <<END
+The type of output produced by activation function
+following this operation.
+END
+  }
+  summary: "Perform a quantized matrix multiplication of  `a` by the matrix `b`."
+  description: <<END
+The inputs must be two-dimensional matrices and the inner dimension of
+`a` (after being transposed if `transpose_a` is non-zero) must match the
+outer dimension of `b` (after being transposed if `transposed_b` is
+non-zero).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizedMaxPool.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizedMaxPool.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..208950754b169ed77b29a0d270188706ef4b607c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizedMaxPool.pbtxt
@@ -0,0 +1,54 @@
+op {
+  graph_op_name: "QuantizedMaxPool"
+  in_arg {
+    name: "input"
+    description: <<END
+The 4D (batch x rows x cols x depth) Tensor to MaxReduce over.
+END
+  }
+  in_arg {
+    name: "min_input"
+    description: <<END
+The float value that the lowest quantized input value represents.
+END
+  }
+  in_arg {
+    name: "max_input"
+    description: <<END
+The float value that the highest quantized input value represents.
+END
+  }
+  out_arg {
+    name: "min_output"
+    description: <<END
+The float value that the lowest quantized output value represents.
+END
+  }
+  out_arg {
+    name: "max_output"
+    description: <<END
+The float value that the highest quantized output value represents.
+END
+  }
+  attr {
+    name: "ksize"
+    description: <<END
+The size of the window for each dimension of the input tensor.
+The length must be 4 to match the number of dimensions of the input.
+END
+  }
+  attr {
+    name: "strides"
+    description: <<END
+The stride of the sliding window for each dimension of the input
+tensor. The length must be 4 to match the number of dimensions of the input.
+END
+  }
+  attr {
+    name: "padding"
+    description: <<END
+The type of padding algorithm to use.
+END
+  }
+  summary: "Produces the max pool of the input tensor for quantized types."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizedMul.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizedMul.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a6061204f359f5c374b9587a32de436a13eebb2d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizedMul.pbtxt
@@ -0,0 +1,43 @@
+op {
+  graph_op_name: "QuantizedMul"
+  in_arg {
+    name: "min_x"
+    description: <<END
+The float value that the lowest quantized `x` value represents.
+END
+  }
+  in_arg {
+    name: "max_x"
+    description: <<END
+The float value that the highest quantized `x` value represents.
+END
+  }
+  in_arg {
+    name: "min_y"
+    description: <<END
+The float value that the lowest quantized `y` value represents.
+END
+  }
+  in_arg {
+    name: "max_y"
+    description: <<END
+The float value that the highest quantized `y` value represents.
+END
+  }
+  out_arg {
+    name: "min_z"
+    description: <<END
+The float value that the lowest quantized output value represents.
+END
+  }
+  out_arg {
+    name: "max_z"
+    description: <<END
+The float value that the highest quantized output value represents.
+
+*NOTE*: `QuantizedMul` supports limited forms of broadcasting. More about
+broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+  }
+  summary: "Returns x * y element-wise, working on quantized buffers."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizedRelu.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizedRelu.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..519fbf1806dcdecc5d31d1fab77f9ff35922ac2d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizedRelu.pbtxt
@@ -0,0 +1,34 @@
+op {
+  graph_op_name: "QuantizedRelu"
+  in_arg {
+    name: "min_features"
+    description: <<END
+The float value that the lowest quantized value represents.
+END
+  }
+  in_arg {
+    name: "max_features"
+    description: <<END
+The float value that the highest quantized value represents.
+END
+  }
+  out_arg {
+    name: "activations"
+    description: <<END
+Has the same output shape as "features".
+END
+  }
+  out_arg {
+    name: "min_activations"
+    description: <<END
+The float value that the lowest quantized value represents.
+END
+  }
+  out_arg {
+    name: "max_activations"
+    description: <<END
+The float value that the highest quantized value represents.
+END
+  }
+  summary: "Computes Quantized Rectified Linear: `max(features, 0)`"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizedRelu6.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizedRelu6.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..62fd01b4aaba69bb46f1d6052fb76dede326e400
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizedRelu6.pbtxt
@@ -0,0 +1,34 @@
+op {
+  graph_op_name: "QuantizedRelu6"
+  in_arg {
+    name: "min_features"
+    description: <<END
+The float value that the lowest quantized value represents.
+END
+  }
+  in_arg {
+    name: "max_features"
+    description: <<END
+The float value that the highest quantized value represents.
+END
+  }
+  out_arg {
+    name: "activations"
+    description: <<END
+Has the same output shape as "features".
+END
+  }
+  out_arg {
+    name: "min_activations"
+    description: <<END
+The float value that the lowest quantized value represents.
+END
+  }
+  out_arg {
+    name: "max_activations"
+    description: <<END
+The float value that the highest quantized value represents.
+END
+  }
+  summary: "Computes Quantized Rectified Linear 6: `min(max(features, 0), 6)`"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizedReluX.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizedReluX.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5763a19677fd4b3580e7a5f613692ad0290d701d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizedReluX.pbtxt
@@ -0,0 +1,34 @@
+op {
+  graph_op_name: "QuantizedReluX"
+  in_arg {
+    name: "min_features"
+    description: <<END
+The float value that the lowest quantized value represents.
+END
+  }
+  in_arg {
+    name: "max_features"
+    description: <<END
+The float value that the highest quantized value represents.
+END
+  }
+  out_arg {
+    name: "activations"
+    description: <<END
+Has the same output shape as "features".
+END
+  }
+  out_arg {
+    name: "min_activations"
+    description: <<END
+The float value that the lowest quantized value represents.
+END
+  }
+  out_arg {
+    name: "max_activations"
+    description: <<END
+The float value that the highest quantized value represents.
+END
+  }
+  summary: "Computes Quantized Rectified Linear X: `min(max(features, 0), max_value)`"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizedReshape.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizedReshape.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b20333f8c71ef7aced5731811059200c2c9a6243
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizedReshape.pbtxt
@@ -0,0 +1,37 @@
+op {
+  graph_op_name: "QuantizedReshape"
+  in_arg {
+    name: "shape"
+    description: <<END
+Defines the shape of the output tensor.
+END
+  }
+  in_arg {
+    name: "input_min"
+    description: <<END
+The minimum value of the input.
+END
+  }
+  in_arg {
+    name: "input_max"
+    description: <<END
+The maximum value of the input.
+END
+  }
+  out_arg {
+    name: "output_min"
+    description: <<END
+This value is copied from input_min.
+END
+  }
+  out_arg {
+    name: "output_max"
+    description: <<END
+This value is copied from input_max.
+END
+  }
+  summary: "Reshapes a quantized tensor as per the Reshape op."
+  description: <<END
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QuantizedResizeBilinear.pbtxt b/tensorflow/core/api_def/base_api/api_def_QuantizedResizeBilinear.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6b3ba72e530043746a33a9467594ed8fb49dd2e5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QuantizedResizeBilinear.pbtxt
@@ -0,0 +1,35 @@
+op {
+  graph_op_name: "QuantizedResizeBilinear"
+  in_arg {
+    name: "images"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.
+END
+  }
+  in_arg {
+    name: "size"
+    description: <<END
+= A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+new size for the images.
+END
+  }
+  out_arg {
+    name: "resized_images"
+    description: <<END
+4-D with shape
+`[batch, new_height, new_width, channels]`.
+END
+  }
+  attr {
+    name: "align_corners"
+    description: <<END
+If true, rescale input by (new_height - 1) / (height - 1), which
+exactly aligns the 4 corners of images and resized images. If false, rescale
+by new_height / height. Treat similarly the width dimension.
+END
+  }
+  summary: "Resize quantized `images` to `size` using quantized bilinear interpolation."
+  description: <<END
+Input images and output images must be quantized types.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QueueClose.pbtxt b/tensorflow/core/api_def/base_api/api_def_QueueClose.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..950425a853e1502980e5ada1ce0598530afed1c5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QueueClose.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "QueueClose"
+  visibility: SKIP
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a queue.
+END
+  }
+  attr {
+    name: "cancel_pending_enqueues"
+    description: <<END
+If true, all pending enqueue requests that are
+blocked on the given queue will be canceled.
+END
+  }
+  summary: "Closes the given queue."
+  description: <<END
+This operation signals that no more elements will be enqueued in the
+given queue. Subsequent Enqueue(Many) operations will fail.
+Subsequent Dequeue(Many) operations will continue to succeed if
+sufficient elements remain in the queue. Subsequent Dequeue(Many)
+operations that would block will fail immediately.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QueueCloseV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_QueueCloseV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a5603269a02acdf297202a79ea6d1231db9f42e7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QueueCloseV2.pbtxt
@@ -0,0 +1,27 @@
+op {
+  graph_op_name: "QueueCloseV2"
+  endpoint {
+    name: "QueueClose"
+  }
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a queue.
+END
+  }
+  attr {
+    name: "cancel_pending_enqueues"
+    description: <<END
+If true, all pending enqueue requests that are
+blocked on the given queue will be canceled.
+END
+  }
+  summary: "Closes the given queue."
+  description: <<END
+This operation signals that no more elements will be enqueued in the
+given queue. Subsequent Enqueue(Many) operations will fail.
+Subsequent Dequeue(Many) operations will continue to succeed if
+sufficient elements remain in the queue. Subsequent Dequeue(Many)
+operations that would block will fail immediately.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QueueDequeue.pbtxt b/tensorflow/core/api_def/base_api/api_def_QueueDequeue.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3290e10f0b32d7ea303056b3fb6ba64460590d15
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QueueDequeue.pbtxt
@@ -0,0 +1,39 @@
+op {
+  graph_op_name: "QueueDequeue"
+  visibility: SKIP
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a queue.
+END
+  }
+  out_arg {
+    name: "components"
+    description: <<END
+One or more tensors that were dequeued as a tuple.
+END
+  }
+  attr {
+    name: "component_types"
+    description: <<END
+The type of each component in a tuple.
+END
+  }
+  attr {
+    name: "timeout_ms"
+    description: <<END
+If the queue is empty, this operation will block for up to
+timeout_ms milliseconds.
+Note: This option is not supported yet.
+END
+  }
+  summary: "Dequeues a tuple of one or more tensors from the given queue."
+  description: <<END
+This operation has k outputs, where k is the number of components
+in the tuples stored in the given queue, and output i is the ith
+component of the dequeued tuple.
+
+N.B. If the queue is empty, this operation will block until an element
+has been dequeued (or 'timeout_ms' elapses, if specified).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QueueDequeueMany.pbtxt b/tensorflow/core/api_def/base_api/api_def_QueueDequeueMany.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2247b37bb2f40f0216f9c4b17c966a4f4c83596d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QueueDequeueMany.pbtxt
@@ -0,0 +1,52 @@
+op {
+  graph_op_name: "QueueDequeueMany"
+  visibility: SKIP
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a queue.
+END
+  }
+  in_arg {
+    name: "n"
+    description: <<END
+The number of tuples to dequeue.
+END
+  }
+  out_arg {
+    name: "components"
+    description: <<END
+One or more tensors that were dequeued as a tuple.
+END
+  }
+  attr {
+    name: "component_types"
+    description: <<END
+The type of each component in a tuple.
+END
+  }
+  attr {
+    name: "timeout_ms"
+    description: <<END
+If the queue has fewer than n elements, this operation
+will block for up to timeout_ms milliseconds.
+Note: This option is not supported yet.
+END
+  }
+  summary: "Dequeues `n` tuples of one or more tensors from the given queue."
+  description: <<END
+If the queue is closed and there are fewer than `n` elements, then an
+OutOfRange error is returned.
+
+This operation concatenates queue-element component tensors along the
+0th dimension to make a single component tensor.  All of the components
+in the dequeued tuple will have size `n` in the 0th dimension.
+
+This operation has `k` outputs, where `k` is the number of components in
+the tuples stored in the given queue, and output `i` is the ith
+component of the dequeued tuple.
+
+N.B. If the queue is empty, this operation will block until `n` elements
+have been dequeued (or 'timeout_ms' elapses, if specified).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QueueDequeueManyV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_QueueDequeueManyV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..34a65c2944d0010f49ecf1243229d09ec7e7e1e9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QueueDequeueManyV2.pbtxt
@@ -0,0 +1,54 @@
+op {
+  graph_op_name: "QueueDequeueManyV2"
+  endpoint {
+    name: "QueueDequeueMany"
+  }
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a queue.
+END
+  }
+  in_arg {
+    name: "n"
+    description: <<END
+The number of tuples to dequeue.
+END
+  }
+  out_arg {
+    name: "components"
+    description: <<END
+One or more tensors that were dequeued as a tuple.
+END
+  }
+  attr {
+    name: "component_types"
+    description: <<END
+The type of each component in a tuple.
+END
+  }
+  attr {
+    name: "timeout_ms"
+    description: <<END
+If the queue has fewer than n elements, this operation
+will block for up to timeout_ms milliseconds.
+Note: This option is not supported yet.
+END
+  }
+  summary: "Dequeues `n` tuples of one or more tensors from the given queue."
+  description: <<END
+If the queue is closed and there are fewer than `n` elements, then an
+OutOfRange error is returned.
+
+This operation concatenates queue-element component tensors along the
+0th dimension to make a single component tensor.  All of the components
+in the dequeued tuple will have size `n` in the 0th dimension.
+
+This operation has `k` outputs, where `k` is the number of components in
+the tuples stored in the given queue, and output `i` is the ith
+component of the dequeued tuple.
+
+N.B. If the queue is empty, this operation will block until `n` elements
+have been dequeued (or 'timeout_ms' elapses, if specified).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QueueDequeueUpTo.pbtxt b/tensorflow/core/api_def/base_api/api_def_QueueDequeueUpTo.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a0c7c204aaa057038796017da433147d05f1bb89
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QueueDequeueUpTo.pbtxt
@@ -0,0 +1,56 @@
+op {
+  graph_op_name: "QueueDequeueUpTo"
+  visibility: SKIP
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a queue.
+END
+  }
+  in_arg {
+    name: "n"
+    description: <<END
+The number of tuples to dequeue.
+END
+  }
+  out_arg {
+    name: "components"
+    description: <<END
+One or more tensors that were dequeued as a tuple.
+END
+  }
+  attr {
+    name: "component_types"
+    description: <<END
+The type of each component in a tuple.
+END
+  }
+  attr {
+    name: "timeout_ms"
+    description: <<END
+If the queue has fewer than n elements, this operation
+will block for up to timeout_ms milliseconds.
+Note: This option is not supported yet.
+END
+  }
+  summary: "Dequeues `n` tuples of one or more tensors from the given queue."
+  description: <<END
+This operation is not supported by all queues.  If a queue does not support
+DequeueUpTo, then an Unimplemented error is returned.
+
+If the queue is closed and there are more than 0 but less than `n`
+elements remaining, then instead of returning an OutOfRange error like
+QueueDequeueMany, less than `n` elements are returned immediately.  If
+the queue is closed and there are 0 elements left in the queue, then
+an OutOfRange error is returned just like in QueueDequeueMany.
+Otherwise the behavior is identical to QueueDequeueMany:
+
+This operation concatenates queue-element component tensors along the
+0th dimension to make a single component tensor.  All of the components
+in the dequeued tuple will have size `n` in the 0th dimension.
+
+This operation has k outputs, where `k` is the number of components in
+the tuples stored in the given queue, and output `i` is the ith
+component of the dequeued tuple.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QueueDequeueUpToV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_QueueDequeueUpToV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..003e5f2c75c593e5be256237d89be23341459642
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QueueDequeueUpToV2.pbtxt
@@ -0,0 +1,58 @@
+op {
+  graph_op_name: "QueueDequeueUpToV2"
+  endpoint {
+    name: "QueueDequeueUpTo"
+  }
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a queue.
+END
+  }
+  in_arg {
+    name: "n"
+    description: <<END
+The number of tuples to dequeue.
+END
+  }
+  out_arg {
+    name: "components"
+    description: <<END
+One or more tensors that were dequeued as a tuple.
+END
+  }
+  attr {
+    name: "component_types"
+    description: <<END
+The type of each component in a tuple.
+END
+  }
+  attr {
+    name: "timeout_ms"
+    description: <<END
+If the queue has fewer than n elements, this operation
+will block for up to timeout_ms milliseconds.
+Note: This option is not supported yet.
+END
+  }
+  summary: "Dequeues `n` tuples of one or more tensors from the given queue."
+  description: <<END
+This operation is not supported by all queues.  If a queue does not support
+DequeueUpTo, then an Unimplemented error is returned.
+
+If the queue is closed and there are more than 0 but less than `n`
+elements remaining, then instead of returning an OutOfRange error like
+QueueDequeueMany, less than `n` elements are returned immediately.  If
+the queue is closed and there are 0 elements left in the queue, then
+an OutOfRange error is returned just like in QueueDequeueMany.
+Otherwise the behavior is identical to QueueDequeueMany:
+
+This operation concatenates queue-element component tensors along the
+0th dimension to make a single component tensor.  All of the components
+in the dequeued tuple will have size n in the 0th dimension.
+
+This operation has `k` outputs, where `k` is the number of components in
+the tuples stored in the given queue, and output `i` is the ith
+component of the dequeued tuple.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QueueDequeueV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_QueueDequeueV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fda760cfe569e9775cf1ceab3cd4cf4384b0c66b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QueueDequeueV2.pbtxt
@@ -0,0 +1,41 @@
+op {
+  graph_op_name: "QueueDequeueV2"
+  endpoint {
+    name: "QueueDequeue"
+  }
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a queue.
+END
+  }
+  out_arg {
+    name: "components"
+    description: <<END
+One or more tensors that were dequeued as a tuple.
+END
+  }
+  attr {
+    name: "component_types"
+    description: <<END
+The type of each component in a tuple.
+END
+  }
+  attr {
+    name: "timeout_ms"
+    description: <<END
+If the queue is empty, this operation will block for up to
+timeout_ms milliseconds.
+Note: This option is not supported yet.
+END
+  }
+  summary: "Dequeues a tuple of one or more tensors from the given queue."
+  description: <<END
+This operation has k outputs, where k is the number of components
+in the tuples stored in the given queue, and output i is the ith
+component of the dequeued tuple.
+
+N.B. If the queue is empty, this operation will block until an element
+has been dequeued (or 'timeout_ms' elapses, if specified).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QueueEnqueue.pbtxt b/tensorflow/core/api_def/base_api/api_def_QueueEnqueue.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..76477b51da2868e03715f6fbae515b7003a10455
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QueueEnqueue.pbtxt
@@ -0,0 +1,32 @@
+op {
+  graph_op_name: "QueueEnqueue"
+  visibility: SKIP
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a queue.
+END
+  }
+  in_arg {
+    name: "components"
+    description: <<END
+One or more tensors from which the enqueued tensors should be taken.
+END
+  }
+  attr {
+    name: "timeout_ms"
+    description: <<END
+If the queue is full, this operation will block for up to
+timeout_ms milliseconds.
+Note: This option is not supported yet.
+END
+  }
+  summary: "Enqueues a tuple of one or more tensors in the given queue."
+  description: <<END
+The components input has k elements, which correspond to the components of
+tuples stored in the given queue.
+
+N.B. If the queue is full, this operation will block until the given
+element has been enqueued (or 'timeout_ms' elapses, if specified).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QueueEnqueueMany.pbtxt b/tensorflow/core/api_def/base_api/api_def_QueueEnqueueMany.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cbd282d9b9d16dfad48400b89dbe48d39ddcdaac
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QueueEnqueueMany.pbtxt
@@ -0,0 +1,37 @@
+op {
+  graph_op_name: "QueueEnqueueMany"
+  visibility: SKIP
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a queue.
+END
+  }
+  in_arg {
+    name: "components"
+    description: <<END
+One or more tensors from which the enqueued tensors should
+be taken.
+END
+  }
+  attr {
+    name: "timeout_ms"
+    description: <<END
+If the queue is too full, this operation will block for up
+to timeout_ms milliseconds.
+Note: This option is not supported yet.
+END
+  }
+  summary: "Enqueues zero or more tuples of one or more tensors in the given queue."
+  description: <<END
+This operation slices each component tensor along the 0th dimension to
+make multiple queue elements. All of the tuple components must have the
+same size in the 0th dimension.
+
+The components input has k elements, which correspond to the components of
+tuples stored in the given queue.
+
+N.B. If the queue is full, this operation will block until the given
+elements have been enqueued (or 'timeout_ms' elapses, if specified).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QueueEnqueueManyV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_QueueEnqueueManyV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4c721caa253487f69c8f846810954e524db259f8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QueueEnqueueManyV2.pbtxt
@@ -0,0 +1,39 @@
+op {
+  graph_op_name: "QueueEnqueueManyV2"
+  endpoint {
+    name: "QueueEnqueueMany"
+  }
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a queue.
+END
+  }
+  in_arg {
+    name: "components"
+    description: <<END
+One or more tensors from which the enqueued tensors should
+be taken.
+END
+  }
+  attr {
+    name: "timeout_ms"
+    description: <<END
+If the queue is too full, this operation will block for up
+to timeout_ms milliseconds.
+Note: This option is not supported yet.
+END
+  }
+  summary: "Enqueues zero or more tuples of one or more tensors in the given queue."
+  description: <<END
+This operation slices each component tensor along the 0th dimension to
+make multiple queue elements. All of the tuple components must have the
+same size in the 0th dimension.
+
+The components input has k elements, which correspond to the components of
+tuples stored in the given queue.
+
+N.B. If the queue is full, this operation will block until the given
+elements have been enqueued (or 'timeout_ms' elapses, if specified).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QueueEnqueueV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_QueueEnqueueV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..367d197cb09fe0a213ae8f8d8c70a6a699a12aa2
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QueueEnqueueV2.pbtxt
@@ -0,0 +1,34 @@
+op {
+  graph_op_name: "QueueEnqueueV2"
+  endpoint {
+    name: "QueueEnqueue"
+  }
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a queue.
+END
+  }
+  in_arg {
+    name: "components"
+    description: <<END
+One or more tensors from which the enqueued tensors should be taken.
+END
+  }
+  attr {
+    name: "timeout_ms"
+    description: <<END
+If the queue is full, this operation will block for up to
+timeout_ms milliseconds.
+Note: This option is not supported yet.
+END
+  }
+  summary: "Enqueues a tuple of one or more tensors in the given queue."
+  description: <<END
+The components input has k elements, which correspond to the components of
+tuples stored in the given queue.
+
+N.B. If the queue is full, this operation will block until the given
+element has been enqueued (or 'timeout_ms' elapses, if specified).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QueueIsClosed.pbtxt b/tensorflow/core/api_def/base_api/api_def_QueueIsClosed.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9412b2e6d691cccc9beab727b147a4de73fa8a24
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QueueIsClosed.pbtxt
@@ -0,0 +1,14 @@
+op {
+  graph_op_name: "QueueIsClosed"
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a queue.
+END
+  }
+  summary: "Returns true if queue is closed."
+  description: <<END
+This operation returns true if the queue is closed and false if the queue
+is open.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QueueIsClosedV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_QueueIsClosedV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..45aa4d10fbb24d877e5ed1e17628df164ae5ac2a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QueueIsClosedV2.pbtxt
@@ -0,0 +1,14 @@
+op {
+  graph_op_name: "QueueIsClosedV2"
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a queue.
+END
+  }
+  summary: "Returns true if queue is closed."
+  description: <<END
+This operation returns true if the queue is closed and false if the queue
+is open.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QueueSize.pbtxt b/tensorflow/core/api_def/base_api/api_def_QueueSize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..74fd38c0ee1bb6323ad830b8aa39a8c7eb0c67ee
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QueueSize.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "QueueSize"
+  visibility: SKIP
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a queue.
+END
+  }
+  out_arg {
+    name: "size"
+    description: <<END
+The number of elements in the given queue.
+END
+  }
+  summary: "Computes the number of elements in the given queue."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_QueueSizeV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_QueueSizeV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f0cfa40f652681bd30fc1493bdcc8fc55cca31de
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_QueueSizeV2.pbtxt
@@ -0,0 +1,19 @@
+op {
+  graph_op_name: "QueueSizeV2"
+  endpoint {
+    name: "QueueSize"
+  }
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a queue.
+END
+  }
+  out_arg {
+    name: "size"
+    description: <<END
+The number of elements in the given queue.
+END
+  }
+  summary: "Computes the number of elements in the given queue."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_R.pbtxt b/tensorflow/core/api_def/base_api/api_def_R.pbtxt
deleted file mode 100644
index 4c398c97713fab491204a7793046569142eb5f6e..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_R.pbtxt
+++ /dev/null
@@ -1,1392 +0,0 @@
-op {
-  graph_op_name: "RFFT"
-  endpoint {
-    name: "RFFT"
-  }
-  summary: "Real-valued fast Fourier transform."
-  description: <<END
-Computes the 1-dimensional discrete Fourier transform of a real-valued signal
-over the inner-most dimension of `input`.
-
-Since the DFT of a real signal is Hermitian-symmetric, `RFFT` only returns the
-`fft_length / 2 + 1` unique components of the FFT: the zero-frequency term,
-followed by the `fft_length / 2` positive-frequency terms.
-
-Along the axis `RFFT` is computed on, if `fft_length` is smaller than the
-corresponding dimension of `input`, the dimension is cropped. If it is larger,
-the dimension is padded with zeros.
-END
-}
-op {
-  graph_op_name: "RFFT2D"
-  endpoint {
-    name: "RFFT2D"
-  }
-  summary: "2D real-valued fast Fourier transform."
-  description: <<END
-Computes the 2-dimensional discrete Fourier transform of a real-valued signal
-over the inner-most 2 dimensions of `input`.
-
-Since the DFT of a real signal is Hermitian-symmetric, `RFFT2D` only returns the
-`fft_length / 2 + 1` unique components of the FFT for the inner-most dimension
-of `output`: the zero-frequency term, followed by the `fft_length / 2`
-positive-frequency terms.
-
-Along each axis `RFFT2D` is computed on, if `fft_length` is smaller than the
-corresponding dimension of `input`, the dimension is cropped. If it is larger,
-the dimension is padded with zeros.
-END
-}
-op {
-  graph_op_name: "RFFT3D"
-  endpoint {
-    name: "RFFT3D"
-  }
-  summary: "3D real-valued fast Fourier transform."
-  description: <<END
-Computes the 3-dimensional discrete Fourier transform of a real-valued signal
-over the inner-most 3 dimensions of `input`.
-
-Since the DFT of a real signal is Hermitian-symmetric, `RFFT3D` only returns the
-`fft_length / 2 + 1` unique components of the FFT for the inner-most dimension
-of `output`: the zero-frequency term, followed by the `fft_length / 2`
-positive-frequency terms.
-
-Along each axis `RFFT3D` is computed on, if `fft_length` is smaller than the
-corresponding dimension of `input`, the dimension is cropped. If it is larger,
-the dimension is padded with zeros.
-END
-}
-op {
-  graph_op_name: "RGBToHSV"
-  endpoint {
-    name: "RGBToHSV"
-  }
-  summary: "Converts one or more images from RGB to HSV."
-  description: <<END
-Outputs a tensor of the same shape as the `images` tensor, containing the HSV
-value of the pixels. The output is only well defined if the value in `images`
-are in `[0,1]`.
-
-`output[..., 0]` contains hue, `output[..., 1]` contains saturation, and
-`output[..., 2]` contains value. All HSV values are in `[0,1]`. A hue of 0
-corresponds to pure red, hue 1/3 is pure green, and 2/3 is pure blue.
-END
-}
-op {
-  graph_op_name: "RandomCrop"
-  endpoint {
-    name: "RandomCrop"
-  }
-  summary: "Randomly crop `image`."
-  description: <<END
-`size` is a 1-D int64 tensor with 2 elements representing the crop height and
-width.  The values must be non negative.
-
-This Op picks a random location in `image` and crops a `height` by `width`
-rectangle from that location.  The random location is picked so the cropped
-area will fit inside the original image.
-END
-}
-op {
-  graph_op_name: "RandomGamma"
-  endpoint {
-    name: "RandomGamma"
-  }
-  summary: "Outputs random values from the Gamma distribution(s) described by alpha."
-  description: <<END
-This op uses the algorithm by Marsaglia et al. to acquire samples via
-transformation-rejection from pairs of uniform and normal random variables.
-See http://dl.acm.org/citation.cfm?id=358414
-END
-}
-op {
-  graph_op_name: "RandomPoisson"
-  endpoint {
-    name: "RandomPoisson"
-  }
-  summary: "Outputs random values from the Poisson distribution(s) described by rate."
-  description: <<END
-This op uses two algorithms, depending on rate. If rate >= 10, then
-the algorithm by Hormann is used to acquire samples via
-transformation-rejection.
-See http://www.sciencedirect.com/science/article/pii/0167668793909974.
-
-Otherwise, Knuth's algorithm is used to acquire samples via multiplying uniform
-random variables.
-See Donald E. Knuth (1969). Seminumerical Algorithms. The Art of Computer
-Programming, Volume 2. Addison Wesley
-END
-}
-op {
-  graph_op_name: "RandomPoissonV2"
-  endpoint {
-    name: "RandomPoissonV2"
-  }
-  summary: "Outputs random values from the Poisson distribution(s) described by rate."
-  description: <<END
-This op uses two algorithms, depending on rate. If rate >= 10, then
-the algorithm by Hormann is used to acquire samples via
-transformation-rejection.
-See http://www.sciencedirect.com/science/article/pii/0167668793909974.
-
-Otherwise, Knuth's algorithm is used to acquire samples via multiplying uniform
-random variables.
-See Donald E. Knuth (1969). Seminumerical Algorithms. The Art of Computer
-Programming, Volume 2. Addison Wesley
-END
-}
-op {
-  graph_op_name: "RandomShuffle"
-  endpoint {
-    name: "RandomShuffle"
-  }
-  summary: "Randomly shuffles a tensor along its first dimension."
-  description: <<END
-  The tensor is shuffled along dimension 0, such that each `value[j]` is mapped
-  to one and only one `output[i]`. For example, a mapping that might occur for a
-  3x2 tensor is:
-
-```
-[[1, 2],       [[5, 6],
- [3, 4],  ==>   [1, 2],
- [5, 6]]        [3, 4]]
-```
-END
-}
-op {
-  graph_op_name: "RandomShuffleQueue"
-  endpoint {
-    name: "RandomShuffleQueue"
-  }
-  summary: "A queue that randomizes the order of elements."
-}
-op {
-  graph_op_name: "RandomShuffleQueueV2"
-  endpoint {
-    name: "RandomShuffleQueueV2"
-  }
-  summary: "A queue that randomizes the order of elements."
-}
-op {
-  graph_op_name: "RandomStandardNormal"
-  endpoint {
-    name: "RandomStandardNormal"
-  }
-  summary: "Outputs random values from a normal distribution."
-  description: <<END
-The generated values will have mean 0 and standard deviation 1.
-END
-}
-op {
-  graph_op_name: "RandomUniform"
-  endpoint {
-    name: "RandomUniform"
-  }
-  summary: "Outputs random values from a uniform distribution."
-  description: <<END
-The generated values follow a uniform distribution in the range `[0, 1)`. The
-lower bound 0 is included in the range, while the upper bound 1 is excluded.
-END
-}
-op {
-  graph_op_name: "RandomUniformInt"
-  endpoint {
-    name: "RandomUniformInt"
-  }
-  summary: "Outputs random integers from a uniform distribution."
-  description: <<END
-The generated values are uniform integers in the range `[minval, maxval)`.
-The lower bound `minval` is included in the range, while the upper bound
-`maxval` is excluded.
-
-The random integers are slightly biased unless `maxval - minval` is an exact
-power of two.  The bias is small for values of `maxval - minval` significantly
-smaller than the range of the output (either `2^32` or `2^64`).
-END
-}
-op {
-  graph_op_name: "Range"
-  endpoint {
-    name: "Range"
-  }
-  summary: "Creates a sequence of numbers."
-  description: <<END
-This operation creates a sequence of numbers that begins at `start` and
-extends by increments of `delta` up to but not including `limit`.
-
-For example:
-
-```
-# 'start' is 3
-# 'limit' is 18
-# 'delta' is 3
-tf.range(start, limit, delta) ==> [3, 6, 9, 12, 15]
-```
-END
-}
-op {
-  graph_op_name: "RangeDataset"
-  endpoint {
-    name: "RangeDataset"
-  }
-  summary: "Creates a dataset with a range of values. Corresponds to python\'s xrange."
-}
-op {
-  graph_op_name: "Rank"
-  endpoint {
-    name: "Rank"
-  }
-  summary: "Returns the rank of a tensor."
-  description: <<END
-This operation returns an integer representing the rank of `input`.
-
-For example:
-
-```
-# 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
-# shape of tensor 't' is [2, 2, 3]
-rank(t) ==> 3
-```
-
-**Note**: The rank of a tensor is not the same as the rank of a matrix. The rank
-of a tensor is the number of indices required to uniquely select each element
-of the tensor. Rank is also known as "order", "degree", or "ndims."
-END
-}
-op {
-  graph_op_name: "ReadFile"
-  endpoint {
-    name: "ReadFile"
-  }
-  summary: "Reads and outputs the entire contents of the input filename."
-}
-op {
-  graph_op_name: "ReaderNumRecordsProduced"
-  endpoint {
-    name: "ReaderNumRecordsProduced"
-  }
-  summary: "Returns the number of records this Reader has produced."
-  description: <<END
-This is the same as the number of ReaderRead executions that have
-succeeded.
-END
-}
-op {
-  graph_op_name: "ReaderNumRecordsProducedV2"
-  endpoint {
-    name: "ReaderNumRecordsProducedV2"
-  }
-  summary: "Returns the number of records this Reader has produced."
-  description: <<END
-This is the same as the number of ReaderRead executions that have
-succeeded.
-END
-}
-op {
-  graph_op_name: "ReaderNumWorkUnitsCompleted"
-  endpoint {
-    name: "ReaderNumWorkUnitsCompleted"
-  }
-  summary: "Returns the number of work units this Reader has finished processing."
-}
-op {
-  graph_op_name: "ReaderNumWorkUnitsCompletedV2"
-  endpoint {
-    name: "ReaderNumWorkUnitsCompletedV2"
-  }
-  summary: "Returns the number of work units this Reader has finished processing."
-}
-op {
-  graph_op_name: "ReaderRead"
-  endpoint {
-    name: "ReaderRead"
-  }
-  summary: "Returns the next record (key, value pair) produced by a Reader."
-  description: <<END
-Will dequeue from the input queue if necessary (e.g. when the
-Reader needs to start reading from a new file since it has finished
-with the previous file).
-END
-}
-op {
-  graph_op_name: "ReaderReadUpTo"
-  endpoint {
-    name: "ReaderReadUpTo"
-  }
-  summary: "Returns up to `num_records` (key, value) pairs produced by a Reader."
-  description: <<END
-Will dequeue from the input queue if necessary (e.g. when the
-Reader needs to start reading from a new file since it has finished
-with the previous file).
-It may return less than `num_records` even before the last batch.
-END
-}
-op {
-  graph_op_name: "ReaderReadUpToV2"
-  endpoint {
-    name: "ReaderReadUpToV2"
-  }
-  summary: "Returns up to `num_records` (key, value) pairs produced by a Reader."
-  description: <<END
-Will dequeue from the input queue if necessary (e.g. when the
-Reader needs to start reading from a new file since it has finished
-with the previous file).
-It may return less than `num_records` even before the last batch.
-END
-}
-op {
-  graph_op_name: "ReaderReadV2"
-  endpoint {
-    name: "ReaderReadV2"
-  }
-  summary: "Returns the next record (key, value pair) produced by a Reader."
-  description: <<END
-Will dequeue from the input queue if necessary (e.g. when the
-Reader needs to start reading from a new file since it has finished
-with the previous file).
-END
-}
-op {
-  graph_op_name: "ReaderReset"
-  endpoint {
-    name: "ReaderReset"
-  }
-  summary: "Restore a Reader to its initial clean state."
-}
-op {
-  graph_op_name: "ReaderResetV2"
-  endpoint {
-    name: "ReaderResetV2"
-  }
-  summary: "Restore a Reader to its initial clean state."
-}
-op {
-  graph_op_name: "ReaderRestoreState"
-  endpoint {
-    name: "ReaderRestoreState"
-  }
-  summary: "Restore a reader to a previously saved state."
-  description: <<END
-Not all Readers support being restored, so this can produce an
-Unimplemented error.
-END
-}
-op {
-  graph_op_name: "ReaderRestoreStateV2"
-  endpoint {
-    name: "ReaderRestoreStateV2"
-  }
-  summary: "Restore a reader to a previously saved state."
-  description: <<END
-Not all Readers support being restored, so this can produce an
-Unimplemented error.
-END
-}
-op {
-  graph_op_name: "ReaderSerializeState"
-  endpoint {
-    name: "ReaderSerializeState"
-  }
-  summary: "Produce a string tensor that encodes the state of a Reader."
-  description: <<END
-Not all Readers support being serialized, so this can produce an
-Unimplemented error.
-END
-}
-op {
-  graph_op_name: "ReaderSerializeStateV2"
-  endpoint {
-    name: "ReaderSerializeStateV2"
-  }
-  summary: "Produce a string tensor that encodes the state of a Reader."
-  description: <<END
-Not all Readers support being serialized, so this can produce an
-Unimplemented error.
-END
-}
-op {
-  graph_op_name: "Real"
-  endpoint {
-    name: "Real"
-  }
-  summary: "Returns the real part of a complex number."
-  description: <<END
-Given a tensor `input` of complex numbers, this operation returns a tensor of
-type `float` that is the real part of each element in `input`. All elements in
-`input` must be complex numbers of the form \\(a + bj\\), where *a* is the real
- part returned by this operation and *b* is the imaginary part.
-
-For example:
-
-```
-# tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
-tf.real(input) ==> [-2.25, 3.25]
-```
-END
-}
-op {
-  graph_op_name: "RealDiv"
-  endpoint {
-    name: "RealDiv"
-  }
-  summary: "Returns x / y element-wise for real types."
-  description: <<END
-If `x` and `y` are reals, this will return the floating-point division.
-
-*NOTE*: `Div` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "Reciprocal"
-  endpoint {
-    name: "Reciprocal"
-  }
-  summary: "Computes the reciprocal of x element-wise."
-  description: <<END
-I.e., \\(y = 1 / x\\).
-END
-}
-op {
-  graph_op_name: "ReciprocalGrad"
-  endpoint {
-    name: "ReciprocalGrad"
-  }
-  summary: "Computes the gradient for the inverse of `x` wrt its input."
-  description: <<END
-Specifically, `grad = -dy * y*y`, where `y = 1/x`, and `dy`
-is the corresponding input gradient.
-END
-}
-op {
-  graph_op_name: "RecordInput"
-  endpoint {
-    name: "RecordInput"
-  }
-  summary: "Emits randomized records."
-}
-op {
-  graph_op_name: "ReduceJoin"
-  endpoint {
-    name: "ReduceJoin"
-  }
-  summary: "Joins a string Tensor across the given dimensions."
-  description: <<END
-Computes the string join across dimensions in the given string Tensor of shape
-`[d_0, d_1, ..., d_n-1]`.  Returns a new Tensor created by joining the input
-strings with the given separator (default: empty string).  Negative indices are
-counted backwards from the end, with `-1` being equivalent to `n - 1`.
-
-For example:
-
-```python
-# tensor `a` is [["a", "b"], ["c", "d"]]
-tf.reduce_join(a, 0) ==> ["ac", "bd"]
-tf.reduce_join(a, 1) ==> ["ab", "cd"]
-tf.reduce_join(a, -2) = tf.reduce_join(a, 0) ==> ["ac", "bd"]
-tf.reduce_join(a, -1) = tf.reduce_join(a, 1) ==> ["ab", "cd"]
-tf.reduce_join(a, 0, keep_dims=True) ==> [["ac", "bd"]]
-tf.reduce_join(a, 1, keep_dims=True) ==> [["ab"], ["cd"]]
-tf.reduce_join(a, 0, separator=".") ==> ["a.c", "b.d"]
-tf.reduce_join(a, [0, 1]) ==> ["acbd"]
-tf.reduce_join(a, [1, 0]) ==> ["abcd"]
-tf.reduce_join(a, []) ==> ["abcd"]
-```
-END
-}
-op {
-  graph_op_name: "RefEnter"
-  endpoint {
-    name: "RefEnter"
-  }
-  summary: "Creates or finds a child frame, and makes `data` available to the child frame."
-  description: <<END
-The unique `frame_name` is used by the `Executor` to identify frames. If
-`is_constant` is true, `output` is a constant in the child frame; otherwise
-it may be changed in the child frame. At most `parallel_iterations` iterations
-are run in parallel in the child frame.
-END
-}
-op {
-  graph_op_name: "RefExit"
-  endpoint {
-    name: "RefExit"
-  }
-  summary: "Exits the current frame to its parent frame."
-  description: <<END
-Exit makes its input `data` available to the parent frame.
-END
-}
-op {
-  graph_op_name: "RefIdentity"
-  endpoint {
-    name: "RefIdentity"
-  }
-  summary: "Return the same ref tensor as the input ref tensor."
-}
-op {
-  graph_op_name: "RefMerge"
-  endpoint {
-    name: "RefMerge"
-  }
-  summary: "Forwards the value of an available tensor from `inputs` to `output`."
-  description: <<END
-`Merge` waits for at least one of the tensors in `inputs` to become available.
-It is usually combined with `Switch` to implement branching.
-
-`Merge` forwards the first tensor for become available to `output`, and sets
-`value_index` to its index in `inputs`.
-END
-}
-op {
-  graph_op_name: "RefNextIteration"
-  endpoint {
-    name: "RefNextIteration"
-  }
-  summary: "Makes its input available to the next iteration."
-}
-op {
-  graph_op_name: "RefSelect"
-  endpoint {
-    name: "RefSelect"
-  }
-  summary: "Forwards the `index`th element of `inputs` to `output`."
-}
-op {
-  graph_op_name: "RefSwitch"
-  endpoint {
-    name: "RefSwitch"
-  }
-  summary: "Forwards the ref tensor `data` to the output port determined by `pred`."
-  description: <<END
-If `pred` is true, the `data` input is forwarded to `output_true`. Otherwise,
-the data goes to `output_false`.
-
-See also `Switch` and `Merge`.
-END
-}
-op {
-  graph_op_name: "Relu"
-  endpoint {
-    name: "Relu"
-  }
-  summary: "Computes rectified linear: `max(features, 0)`."
-}
-op {
-  graph_op_name: "Relu6"
-  endpoint {
-    name: "Relu6"
-  }
-  summary: "Computes rectified linear 6: `min(max(features, 0), 6)`."
-}
-op {
-  graph_op_name: "Relu6Grad"
-  endpoint {
-    name: "Relu6Grad"
-  }
-  summary: "Computes rectified linear 6 gradients for a Relu6 operation."
-}
-op {
-  graph_op_name: "ReluGrad"
-  endpoint {
-    name: "ReluGrad"
-  }
-  summary: "Computes rectified linear gradients for a Relu operation."
-}
-op {
-  graph_op_name: "RemoteCall"
-  endpoint {
-    name: "RemoteCall"
-  }
-  summary: "Runs function `f` on a remote device indicated by `target`."
-}
-op {
-  graph_op_name: "RemoteFusedGraphExecute"
-  endpoint {
-    name: "RemoteFusedGraphExecute"
-  }
-  summary: "Execute a sub graph on a remote processor."
-  description: <<END
-The graph specifications(such as graph itself, input tensors and output names)
-are stored as a serialized protocol buffer of RemoteFusedGraphExecuteInfo
-as serialized_remote_fused_graph_execute_info.
-The specifications will be passed to a dedicated registered
-remote fused graph executor.  The executor will send the graph specifications
-to a remote processor and execute that graph.  The execution results
-will be passed to consumer nodes as outputs of this node.
-END
-}
-op {
-  graph_op_name: "RepeatDataset"
-  endpoint {
-    name: "RepeatDataset"
-  }
-  summary: "Creates a dataset that emits the outputs of `input_dataset` `count` times."
-}
-op {
-  graph_op_name: "RequantizationRange"
-  endpoint {
-    name: "RequantizationRange"
-  }
-  summary: "Given a quantized tensor described by (input, input_min, input_max), outputs a"
-  description: <<END
-range that covers the actual values present in that tensor.  This op is
-typically used to produce the requested_output_min and requested_output_max for
-Requantize.
-END
-}
-op {
-  graph_op_name: "Requantize"
-  endpoint {
-    name: "Requantize"
-  }
-  summary: "Convert the quantized \'input\' tensor into a lower-precision \'output\', using the"
-  description: <<END
-output range specified with 'requested_output_min' and 'requested_output_max'.
-
-[input_min, input_max] are scalar floats that specify the range for the float
-interpretation of the 'input' data. For example, if input_min is -1.0f and
-input_max is 1.0f, and we are dealing with quint16 quantized data, then a 0
-value in the 16-bit data should be interpreted as -1.0f, and a 65535 means 1.0f.
-END
-}
-op {
-  graph_op_name: "Reshape"
-  endpoint {
-    name: "Reshape"
-  }
-  summary: "Reshapes a tensor."
-  description: <<END
-Given `tensor`, this operation returns a tensor that has the same values
-as `tensor` with shape `shape`.
-
-If one component of `shape` is the special value -1, the size of that dimension
-is computed so that the total size remains constant.  In particular, a `shape`
-of `[-1]` flattens into 1-D.  At most one component of `shape` can be -1.
-
-If `shape` is 1-D or higher, then the operation returns a tensor with shape
-`shape` filled with the values of `tensor`. In this case, the number of elements
-implied by `shape` must be the same as the number of elements in `tensor`.
-
-For example:
-
-```
-# tensor 't' is [1, 2, 3, 4, 5, 6, 7, 8, 9]
-# tensor 't' has shape [9]
-reshape(t, [3, 3]) ==> [[1, 2, 3],
-                        [4, 5, 6],
-                        [7, 8, 9]]
-
-# tensor 't' is [[[1, 1], [2, 2]],
-#                [[3, 3], [4, 4]]]
-# tensor 't' has shape [2, 2, 2]
-reshape(t, [2, 4]) ==> [[1, 1, 2, 2],
-                        [3, 3, 4, 4]]
-
-# tensor 't' is [[[1, 1, 1],
-#                 [2, 2, 2]],
-#                [[3, 3, 3],
-#                 [4, 4, 4]],
-#                [[5, 5, 5],
-#                 [6, 6, 6]]]
-# tensor 't' has shape [3, 2, 3]
-# pass '[-1]' to flatten 't'
-reshape(t, [-1]) ==> [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6]
-
-# -1 can also be used to infer the shape
-
-# -1 is inferred to be 9:
-reshape(t, [2, -1]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3],
-                         [4, 4, 4, 5, 5, 5, 6, 6, 6]]
-# -1 is inferred to be 2:
-reshape(t, [-1, 9]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3],
-                         [4, 4, 4, 5, 5, 5, 6, 6, 6]]
-# -1 is inferred to be 3:
-reshape(t, [ 2, -1, 3]) ==> [[[1, 1, 1],
-                              [2, 2, 2],
-                              [3, 3, 3]],
-                             [[4, 4, 4],
-                              [5, 5, 5],
-                              [6, 6, 6]]]
-
-# tensor 't' is [7]
-# shape `[]` reshapes to a scalar
-reshape(t, []) ==> 7
-```
-END
-}
-op {
-  graph_op_name: "ResizeArea"
-  endpoint {
-    name: "ResizeArea"
-  }
-  summary: "Resize `images` to `size` using area interpolation."
-  description: <<END
-Input images can be of different types but output images are always float.
-
-Each output pixel is computed by first transforming the pixel's footprint into
-the input tensor and then averaging the pixels that intersect the footprint. An
-input pixel's contribution to the average is weighted by the fraction of its
-area that intersects the footprint.  This is the same as OpenCV's INTER_AREA.
-END
-}
-op {
-  graph_op_name: "ResizeBicubic"
-  endpoint {
-    name: "ResizeBicubic"
-  }
-  summary: "Resize `images` to `size` using bicubic interpolation."
-  description: <<END
-Input images can be of different types but output images are always float.
-END
-}
-op {
-  graph_op_name: "ResizeBicubicGrad"
-  endpoint {
-    name: "ResizeBicubicGrad"
-  }
-  summary: "Computes the gradient of bicubic interpolation."
-}
-op {
-  graph_op_name: "ResizeBilinear"
-  endpoint {
-    name: "ResizeBilinear"
-  }
-  summary: "Resize `images` to `size` using bilinear interpolation."
-  description: <<END
-Input images can be of different types but output images are always float.
-END
-}
-op {
-  graph_op_name: "ResizeBilinearGrad"
-  endpoint {
-    name: "ResizeBilinearGrad"
-  }
-  summary: "Computes the gradient of bilinear interpolation."
-}
-op {
-  graph_op_name: "ResizeNearestNeighbor"
-  endpoint {
-    name: "ResizeNearestNeighbor"
-  }
-  summary: "Resize `images` to `size` using nearest neighbor interpolation."
-}
-op {
-  graph_op_name: "ResizeNearestNeighborGrad"
-  endpoint {
-    name: "ResizeNearestNeighborGrad"
-  }
-  summary: "Computes the gradient of nearest neighbor interpolation."
-}
-op {
-  graph_op_name: "ResourceApplyAdadelta"
-  endpoint {
-    name: "ResourceApplyAdadelta"
-  }
-  summary: "Update \'*var\' according to the adadelta scheme."
-  description: <<END
-accum = rho() * accum + (1 - rho()) * grad.square();
-update = (update_accum + epsilon).sqrt() * (accum + epsilon()).rsqrt() * grad;
-update_accum = rho() * update_accum + (1 - rho()) * update.square();
-var -= update;
-END
-}
-op {
-  graph_op_name: "ResourceApplyAdagrad"
-  endpoint {
-    name: "ResourceApplyAdagrad"
-  }
-  summary: "Update \'*var\' according to the adagrad scheme."
-  description: <<END
-accum += grad * grad
-var -= lr * grad * (1 / sqrt(accum))
-END
-}
-op {
-  graph_op_name: "ResourceApplyAdagradDA"
-  endpoint {
-    name: "ResourceApplyAdagradDA"
-  }
-  summary: "Update \'*var\' according to the proximal adagrad scheme."
-}
-op {
-  graph_op_name: "ResourceApplyAdam"
-  endpoint {
-    name: "ResourceApplyAdam"
-  }
-  summary: "Update \'*var\' according to the Adam algorithm."
-  description: <<END
-lr_t <- learning_rate * sqrt(1 - beta2^t) / (1 - beta1^t)
-m_t <- beta1 * m_{t-1} + (1 - beta1) * g_t
-v_t <- beta2 * v_{t-1} + (1 - beta2) * g_t * g_t
-variable <- variable - lr_t * m_t / (sqrt(v_t) + epsilon)
-END
-}
-op {
-  graph_op_name: "ResourceApplyCenteredRMSProp"
-  endpoint {
-    name: "ResourceApplyCenteredRMSProp"
-  }
-  summary: "Update \'*var\' according to the centered RMSProp algorithm."
-  description: <<END
-The centered RMSProp algorithm uses an estimate of the centered second moment
-(i.e., the variance) for normalization, as opposed to regular RMSProp, which
-uses the (uncentered) second moment. This often helps with training, but is
-slightly more expensive in terms of computation and memory.
-
-Note that in dense implementation of this algorithm, mg, ms, and mom will
-update even if the grad is zero, but in this sparse implementation, mg, ms,
-and mom will not update in iterations during which the grad is zero.
-
-mean_square = decay * mean_square + (1-decay) * gradient ** 2
-mean_grad = decay * mean_grad + (1-decay) * gradient
-
-Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2)
-
-mg <- rho * mg_{t-1} + (1-rho) * grad
-ms <- rho * ms_{t-1} + (1-rho) * grad * grad
-mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms - mg * mg + epsilon)
-var <- var - mom
-END
-}
-op {
-  graph_op_name: "ResourceApplyFtrl"
-  endpoint {
-    name: "ResourceApplyFtrl"
-  }
-  summary: "Update \'*var\' according to the Ftrl-proximal scheme."
-  description: <<END
-accum_new = accum + grad * grad
-linear += grad - (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
-quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
-var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
-accum = accum_new
-END
-}
-op {
-  graph_op_name: "ResourceApplyFtrlV2"
-  endpoint {
-    name: "ResourceApplyFtrlV2"
-  }
-  summary: "Update \'*var\' according to the Ftrl-proximal scheme."
-  description: <<END
-grad_with_shrinkage = grad + 2 * l2_shrinkage * var
-accum_new = accum + grad_with_shrinkage * grad_with_shrinkage
-linear += grad_with_shrinkage +
-    (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
-quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
-var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
-accum = accum_new
-END
-}
-op {
-  graph_op_name: "ResourceApplyGradientDescent"
-  endpoint {
-    name: "ResourceApplyGradientDescent"
-  }
-  summary: "Update \'*var\' by subtracting \'alpha\' * \'delta\' from it."
-}
-op {
-  graph_op_name: "ResourceApplyMomentum"
-  endpoint {
-    name: "ResourceApplyMomentum"
-  }
-  summary: "Update \'*var\' according to the momentum scheme. Set use_nesterov = True if you"
-  description: <<END
-want to use Nesterov momentum.
-
-accum = accum * momentum + grad
-var -= lr * accum
-END
-}
-op {
-  graph_op_name: "ResourceApplyProximalAdagrad"
-  endpoint {
-    name: "ResourceApplyProximalAdagrad"
-  }
-  summary: "Update \'*var\' and \'*accum\' according to FOBOS with Adagrad learning rate."
-  description: <<END
-accum += grad * grad
-prox_v = var - lr * grad * (1 / sqrt(accum))
-var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}
-END
-}
-op {
-  graph_op_name: "ResourceApplyProximalGradientDescent"
-  endpoint {
-    name: "ResourceApplyProximalGradientDescent"
-  }
-  summary: "Update \'*var\' as FOBOS algorithm with fixed learning rate."
-  description: <<END
-prox_v = var - alpha * delta
-var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}
-END
-}
-op {
-  graph_op_name: "ResourceApplyRMSProp"
-  endpoint {
-    name: "ResourceApplyRMSProp"
-  }
-  summary: "Update \'*var\' according to the RMSProp algorithm."
-  description: <<END
-Note that in dense implementation of this algorithm, ms and mom will
-update even if the grad is zero, but in this sparse implementation, ms
-and mom will not update in iterations during which the grad is zero.
-
-mean_square = decay * mean_square + (1-decay) * gradient ** 2
-Delta = learning_rate * gradient / sqrt(mean_square + epsilon)
-
-ms <- rho * ms_{t-1} + (1-rho) * grad * grad
-mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
-var <- var - mom
-END
-}
-op {
-  graph_op_name: "ResourceSparseApplyAdadelta"
-  endpoint {
-    name: "ResourceSparseApplyAdadelta"
-  }
-  summary: "var: Should be from a Variable()."
-}
-op {
-  graph_op_name: "ResourceSparseApplyAdagrad"
-  endpoint {
-    name: "ResourceSparseApplyAdagrad"
-  }
-  summary: "Update relevant entries in \'*var\' and \'*accum\' according to the adagrad scheme."
-  description: <<END
-That is for rows we have grad for, we update var and accum as follows:
-accum += grad * grad
-var -= lr * grad * (1 / sqrt(accum))
-END
-}
-op {
-  graph_op_name: "ResourceSparseApplyAdagradDA"
-  endpoint {
-    name: "ResourceSparseApplyAdagradDA"
-  }
-  summary: "Update entries in \'*var\' and \'*accum\' according to the proximal adagrad scheme."
-}
-op {
-  graph_op_name: "ResourceSparseApplyCenteredRMSProp"
-  endpoint {
-    name: "ResourceSparseApplyCenteredRMSProp"
-  }
-  summary: "Update \'*var\' according to the centered RMSProp algorithm."
-  description: <<END
-The centered RMSProp algorithm uses an estimate of the centered second moment
-(i.e., the variance) for normalization, as opposed to regular RMSProp, which
-uses the (uncentered) second moment. This often helps with training, but is
-slightly more expensive in terms of computation and memory.
-
-Note that in dense implementation of this algorithm, mg, ms, and mom will
-update even if the grad is zero, but in this sparse implementation, mg, ms,
-and mom will not update in iterations during which the grad is zero.
-
-mean_square = decay * mean_square + (1-decay) * gradient ** 2
-mean_grad = decay * mean_grad + (1-decay) * gradient
-Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2)
-
-ms <- rho * ms_{t-1} + (1-rho) * grad * grad
-mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
-var <- var - mom
-END
-}
-op {
-  graph_op_name: "ResourceSparseApplyFtrl"
-  endpoint {
-    name: "ResourceSparseApplyFtrl"
-  }
-  summary: "Update relevant entries in \'*var\' according to the Ftrl-proximal scheme."
-  description: <<END
-That is for rows we have grad for, we update var, accum and linear as follows:
-accum_new = accum + grad * grad
-linear += grad + (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
-quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
-var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
-accum = accum_new
-END
-}
-op {
-  graph_op_name: "ResourceSparseApplyFtrlV2"
-  endpoint {
-    name: "ResourceSparseApplyFtrlV2"
-  }
-  summary: "Update relevant entries in \'*var\' according to the Ftrl-proximal scheme."
-  description: <<END
-That is for rows we have grad for, we update var, accum and linear as follows:
-grad_with_shrinkage = grad + 2 * l2_shrinkage * var
-accum_new = accum + grad_with_shrinkage * grad_with_shrinkage
-linear += grad_with_shrinkage +
-    (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
-quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
-var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
-accum = accum_new
-END
-}
-op {
-  graph_op_name: "ResourceSparseApplyMomentum"
-  endpoint {
-    name: "ResourceSparseApplyMomentum"
-  }
-  summary: "Update relevant entries in \'*var\' and \'*accum\' according to the momentum scheme."
-  description: <<END
-Set use_nesterov = True if you want to use Nesterov momentum.
-
-That is for rows we have grad for, we update var and accum as follows:
-
-accum = accum * momentum + grad
-var -= lr * accum
-END
-}
-op {
-  graph_op_name: "ResourceSparseApplyProximalAdagrad"
-  endpoint {
-    name: "ResourceSparseApplyProximalAdagrad"
-  }
-  summary: "Sparse update entries in \'*var\' and \'*accum\' according to FOBOS algorithm."
-  description: <<END
-That is for rows we have grad for, we update var and accum as follows:
-accum += grad * grad
-prox_v = var
-prox_v -= lr * grad * (1 / sqrt(accum))
-var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}
-END
-}
-op {
-  graph_op_name: "ResourceSparseApplyProximalGradientDescent"
-  endpoint {
-    name: "ResourceSparseApplyProximalGradientDescent"
-  }
-  summary: "Sparse update \'*var\' as FOBOS algorithm with fixed learning rate."
-  description: <<END
-That is for rows we have grad for, we update var as follows:
-prox_v = var - alpha * grad
-var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}
-END
-}
-op {
-  graph_op_name: "ResourceSparseApplyRMSProp"
-  endpoint {
-    name: "ResourceSparseApplyRMSProp"
-  }
-  summary: "Update \'*var\' according to the RMSProp algorithm."
-  description: <<END
-Note that in dense implementation of this algorithm, ms and mom will
-update even if the grad is zero, but in this sparse implementation, ms
-and mom will not update in iterations during which the grad is zero.
-
-mean_square = decay * mean_square + (1-decay) * gradient ** 2
-Delta = learning_rate * gradient / sqrt(mean_square + epsilon)
-
-ms <- rho * ms_{t-1} + (1-rho) * grad * grad
-mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
-var <- var - mom
-END
-}
-op {
-  graph_op_name: "ResourceStridedSliceAssign"
-  endpoint {
-    name: "ResourceStridedSliceAssign"
-  }
-  summary: "Assign `value` to the sliced l-value reference of `ref`."
-  description: <<END
-The values of `value` are assigned to the positions in the variable
-`ref` that are selected by the slice parameters. The slice parameters
-`begin, `end`, `strides`, etc. work exactly as in `StridedSlice`.
-
-NOTE this op currently does not support broadcasting and so `value`'s
-shape must be exactly the shape produced by the slice of `ref`.
-END
-}
-op {
-  graph_op_name: "Restore"
-  endpoint {
-    name: "Restore"
-  }
-  summary: "Restores a tensor from checkpoint files."
-  description: <<END
-Reads a tensor stored in one or several files. If there are several files (for
-instance because a tensor was saved as slices), `file_pattern` may contain
-wildcard symbols (`*` and `?`) in the filename portion only, not in the
-directory portion.
-
-If a `file_pattern` matches several files, `preferred_shard` can be used to hint
-in which file the requested tensor is likely to be found. This op will first
-open the file at index `preferred_shard` in the list of matching files and try
-to restore tensors from that file.  Only if some tensors or tensor slices are
-not found in that first file, then the Op opens all the files. Setting
-`preferred_shard` to match the value passed as the `shard` input
-of a matching `Save` Op may speed up Restore.  This attribute only affects
-performance, not correctness.  The default value -1 means files are processed in
-order.
-
-See also `RestoreSlice`.
-END
-}
-op {
-  graph_op_name: "RestoreIterator"
-  endpoint {
-    name: "RestoreIterator"
-  }
-  summary: "Restores the state of the `iterator` from the checkpoint saved at `path` using \"SaveIterator\"."
-}
-op {
-  graph_op_name: "RestoreSlice"
-  endpoint {
-    name: "RestoreSlice"
-  }
-  summary: "Restores a tensor from checkpoint files."
-  description: <<END
-This is like `Restore` except that restored tensor can be listed as filling
-only a slice of a larger tensor.  `shape_and_slice` specifies the shape of the
-larger tensor and the slice that the restored tensor covers.
-
-The `shape_and_slice` input has the same format as the
-elements of the `shapes_and_slices` input of the `SaveSlices` op.
-END
-}
-op {
-  graph_op_name: "RestoreV2"
-  endpoint {
-    name: "RestoreV2"
-  }
-  summary: "Restores tensors from a V2 checkpoint."
-  description: <<END
-For backward compatibility with the V1 format, this Op currently allows
-restoring from a V1 checkpoint as well:
-  - This Op first attempts to find the V2 index file pointed to by "prefix", and
-    if found proceed to read it as a V2 checkpoint;
-  - Otherwise the V1 read path is invoked.
-Relying on this behavior is not recommended, as the ability to fall back to read
-V1 might be deprecated and eventually removed.
-
-By default, restores the named tensors in full.  If the caller wishes to restore
-specific slices of stored tensors, "shape_and_slices" should be non-empty
-strings and correspondingly well-formed.
-
-Callers must ensure all the named tensors are indeed stored in the checkpoint.
-END
-}
-op {
-  graph_op_name: "Reverse"
-  endpoint {
-    name: "Reverse"
-  }
-  summary: "Reverses specific dimensions of a tensor."
-  description: <<END
-Given a `tensor`, and a `bool` tensor `dims` representing the dimensions
-of `tensor`, this operation reverses each dimension i of `tensor` where
-`dims[i]` is `True`.
-
-`tensor` can have up to 8 dimensions. The number of dimensions
-of `tensor` must equal the number of elements in `dims`. In other words:
-
-`rank(tensor) = size(dims)`
-
-For example:
-
-```
-# tensor 't' is [[[[ 0,  1,  2,  3],
-#                  [ 4,  5,  6,  7],
-#                  [ 8,  9, 10, 11]],
-#                 [[12, 13, 14, 15],
-#                  [16, 17, 18, 19],
-#                  [20, 21, 22, 23]]]]
-# tensor 't' shape is [1, 2, 3, 4]
-
-# 'dims' is [False, False, False, True]
-reverse(t, dims) ==> [[[[ 3,  2,  1,  0],
-                        [ 7,  6,  5,  4],
-                        [ 11, 10, 9, 8]],
-                       [[15, 14, 13, 12],
-                        [19, 18, 17, 16],
-                        [23, 22, 21, 20]]]]
-
-# 'dims' is [False, True, False, False]
-reverse(t, dims) ==> [[[[12, 13, 14, 15],
-                        [16, 17, 18, 19],
-                        [20, 21, 22, 23]
-                       [[ 0,  1,  2,  3],
-                        [ 4,  5,  6,  7],
-                        [ 8,  9, 10, 11]]]]
-
-# 'dims' is [False, False, True, False]
-reverse(t, dims) ==> [[[[8, 9, 10, 11],
-                        [4, 5, 6, 7],
-                        [0, 1, 2, 3]]
-                       [[20, 21, 22, 23],
-                        [16, 17, 18, 19],
-                        [12, 13, 14, 15]]]]
-```
-END
-}
-op {
-  graph_op_name: "ReverseSequence"
-  endpoint {
-    name: "ReverseSequence"
-  }
-  summary: "Reverses variable length slices."
-  description: <<END
-This op first slices `input` along the dimension `batch_dim`, and for each
-slice `i`, reverses the first `seq_lengths[i]` elements along
-the dimension `seq_dim`.
-
-The elements of `seq_lengths` must obey `seq_lengths[i] <= input.dims[seq_dim]`,
-and `seq_lengths` must be a vector of length `input.dims[batch_dim]`.
-
-The output slice `i` along dimension `batch_dim` is then given by input
-slice `i`, with the first `seq_lengths[i]` slices along dimension
-`seq_dim` reversed.
-
-For example:
-
-```
-# Given this:
-batch_dim = 0
-seq_dim = 1
-input.dims = (4, 8, ...)
-seq_lengths = [7, 2, 3, 5]
-
-# then slices of input are reversed on seq_dim, but only up to seq_lengths:
-output[0, 0:7, :, ...] = input[0, 7:0:-1, :, ...]
-output[1, 0:2, :, ...] = input[1, 2:0:-1, :, ...]
-output[2, 0:3, :, ...] = input[2, 3:0:-1, :, ...]
-output[3, 0:5, :, ...] = input[3, 5:0:-1, :, ...]
-
-# while entries past seq_lens are copied through:
-output[0, 7:, :, ...] = input[0, 7:, :, ...]
-output[1, 2:, :, ...] = input[1, 2:, :, ...]
-output[2, 3:, :, ...] = input[2, 3:, :, ...]
-output[3, 2:, :, ...] = input[3, 2:, :, ...]
-```
-
-In contrast, if:
-
-```
-# Given this:
-batch_dim = 2
-seq_dim = 0
-input.dims = (8, ?, 4, ...)
-seq_lengths = [7, 2, 3, 5]
-
-# then slices of input are reversed on seq_dim, but only up to seq_lengths:
-output[0:7, :, 0, :, ...] = input[7:0:-1, :, 0, :, ...]
-output[0:2, :, 1, :, ...] = input[2:0:-1, :, 1, :, ...]
-output[0:3, :, 2, :, ...] = input[3:0:-1, :, 2, :, ...]
-output[0:5, :, 3, :, ...] = input[5:0:-1, :, 3, :, ...]
-
-# while entries past seq_lens are copied through:
-output[7:, :, 0, :, ...] = input[7:, :, 0, :, ...]
-output[2:, :, 1, :, ...] = input[2:, :, 1, :, ...]
-output[3:, :, 2, :, ...] = input[3:, :, 2, :, ...]
-output[2:, :, 3, :, ...] = input[2:, :, 3, :, ...]
-```
-END
-}
-op {
-  graph_op_name: "ReverseV2"
-  endpoint {
-    name: "ReverseV2"
-  }
-  summary: "Reverses specific dimensions of a tensor."
-  description: <<END
-NOTE `tf.reverse` has now changed behavior in preparation for 1.0.
-`tf.reverse_v2` is currently an alias that will be deprecated before TF 1.0.
-
-Given a `tensor`, and a `int32` tensor `axis` representing the set of
-dimensions of `tensor` to reverse. This operation reverses each dimension
-`i` for which there exists `j` s.t. `axis[j] == i`.
-
-`tensor` can have up to 8 dimensions. The number of dimensions specified
-in `axis` may be 0 or more entries. If an index is specified more than
-once, a InvalidArgument error is raised.
-
-For example:
-
-```
-# tensor 't' is [[[[ 0,  1,  2,  3],
-#                  [ 4,  5,  6,  7],
-#                  [ 8,  9, 10, 11]],
-#                 [[12, 13, 14, 15],
-#                  [16, 17, 18, 19],
-#                  [20, 21, 22, 23]]]]
-# tensor 't' shape is [1, 2, 3, 4]
-
-# 'dims' is [3] or 'dims' is -1
-reverse(t, dims) ==> [[[[ 3,  2,  1,  0],
-                        [ 7,  6,  5,  4],
-                        [ 11, 10, 9, 8]],
-                       [[15, 14, 13, 12],
-                        [19, 18, 17, 16],
-                        [23, 22, 21, 20]]]]
-
-# 'dims' is '[1]' (or 'dims' is '[-3]')
-reverse(t, dims) ==> [[[[12, 13, 14, 15],
-                        [16, 17, 18, 19],
-                        [20, 21, 22, 23]
-                       [[ 0,  1,  2,  3],
-                        [ 4,  5,  6,  7],
-                        [ 8,  9, 10, 11]]]]
-
-# 'dims' is '[2]' (or 'dims' is '[-2]')
-reverse(t, dims) ==> [[[[8, 9, 10, 11],
-                        [4, 5, 6, 7],
-                        [0, 1, 2, 3]]
-                       [[20, 21, 22, 23],
-                        [16, 17, 18, 19],
-                        [12, 13, 14, 15]]]]
-```
-END
-}
-op {
-  graph_op_name: "Rint"
-  endpoint {
-    name: "Rint"
-  }
-  summary: "Returns element-wise integer closest to x."
-  description: <<END
-If the result is midway between two representable values,
-the even representable is chosen.
-For example:
-
-```
-rint(-1.5) ==> -2.0
-rint(0.5000001) ==> 1.0
-rint([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) ==> [-2., -2., -0., 0., 2., 2., 2.]
-```
-END
-}
-op {
-  graph_op_name: "Round"
-  endpoint {
-    name: "Round"
-  }
-  summary: "Rounds the values of a tensor to the nearest integer, element-wise."
-  description: <<END
-Rounds half to even.  Also known as bankers rounding. If you want to round
-according to the current system rounding mode use std::cint.
-END
-}
-op {
-  graph_op_name: "Rsqrt"
-  endpoint {
-    name: "Rsqrt"
-  }
-  summary: "Computes reciprocal of square root of x element-wise."
-  description: <<END
-I.e., \\(y = 1 / \sqrt{x}\\).
-END
-}
-op {
-  graph_op_name: "RsqrtGrad"
-  endpoint {
-    name: "RsqrtGrad"
-  }
-  summary: "Computes the gradient for the rsqrt of `x` wrt its input."
-  description: <<END
-Specifically, `grad = dy * -0.5 * y^3`, where `y = rsqrt(x)`, and `dy`
-is the corresponding input gradient.
-END
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_RFFT.pbtxt b/tensorflow/core/api_def/base_api/api_def_RFFT.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9bf680e2ca0aef7155809ffe2b28cdcb191f2fff
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RFFT.pbtxt
@@ -0,0 +1,40 @@
+op {
+  graph_op_name: "RFFT"
+  in_arg {
+    name: "input"
+    description: <<END
+A float32 tensor.
+END
+  }
+  in_arg {
+    name: "fft_length"
+    description: <<END
+An int32 tensor of shape [1]. The FFT length.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A complex64 tensor of the same rank as `input`. The inner-most
+  dimension of `input` is replaced with the `fft_length / 2 + 1` unique
+  frequency components of its 1D Fourier transform.
+
+@compatibility(numpy)
+Equivalent to np.fft.rfft
+@end_compatibility
+END
+  }
+  summary: "Real-valued fast Fourier transform."
+  description: <<END
+Computes the 1-dimensional discrete Fourier transform of a real-valued signal
+over the inner-most dimension of `input`.
+
+Since the DFT of a real signal is Hermitian-symmetric, `RFFT` only returns the
+`fft_length / 2 + 1` unique components of the FFT: the zero-frequency term,
+followed by the `fft_length / 2` positive-frequency terms.
+
+Along the axis `RFFT` is computed on, if `fft_length` is smaller than the
+corresponding dimension of `input`, the dimension is cropped. If it is larger,
+the dimension is padded with zeros.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RFFT2D.pbtxt b/tensorflow/core/api_def/base_api/api_def_RFFT2D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a901ee704c46556a8fd2a24d300e35f239310eea
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RFFT2D.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "RFFT2D"
+  in_arg {
+    name: "input"
+    description: <<END
+A float32 tensor.
+END
+  }
+  in_arg {
+    name: "fft_length"
+    description: <<END
+An int32 tensor of shape [2]. The FFT length for each dimension.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A complex64 tensor of the same rank as `input`. The inner-most 2
+  dimensions of `input` are replaced with their 2D Fourier transform. The
+  inner-most dimension contains `fft_length / 2 + 1` unique frequency
+  components.
+
+@compatibility(numpy)
+Equivalent to np.fft.rfft2
+@end_compatibility
+END
+  }
+  summary: "2D real-valued fast Fourier transform."
+  description: <<END
+Computes the 2-dimensional discrete Fourier transform of a real-valued signal
+over the inner-most 2 dimensions of `input`.
+
+Since the DFT of a real signal is Hermitian-symmetric, `RFFT2D` only returns the
+`fft_length / 2 + 1` unique components of the FFT for the inner-most dimension
+of `output`: the zero-frequency term, followed by the `fft_length / 2`
+positive-frequency terms.
+
+Along each axis `RFFT2D` is computed on, if `fft_length` is smaller than the
+corresponding dimension of `input`, the dimension is cropped. If it is larger,
+the dimension is padded with zeros.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RFFT3D.pbtxt b/tensorflow/core/api_def/base_api/api_def_RFFT3D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d4a3ad667bab252b480e30061d8e365cd4e762e9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RFFT3D.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "RFFT3D"
+  in_arg {
+    name: "input"
+    description: <<END
+A float32 tensor.
+END
+  }
+  in_arg {
+    name: "fft_length"
+    description: <<END
+An int32 tensor of shape [3]. The FFT length for each dimension.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A complex64 tensor of the same rank as `input`. The inner-most 3
+  dimensions of `input` are replaced with the their 3D Fourier transform. The
+  inner-most dimension contains `fft_length / 2 + 1` unique frequency
+  components.
+
+@compatibility(numpy)
+Equivalent to np.fft.rfftn with 3 dimensions.
+@end_compatibility
+END
+  }
+  summary: "3D real-valued fast Fourier transform."
+  description: <<END
+Computes the 3-dimensional discrete Fourier transform of a real-valued signal
+over the inner-most 3 dimensions of `input`.
+
+Since the DFT of a real signal is Hermitian-symmetric, `RFFT3D` only returns the
+`fft_length / 2 + 1` unique components of the FFT for the inner-most dimension
+of `output`: the zero-frequency term, followed by the `fft_length / 2`
+positive-frequency terms.
+
+Along each axis `RFFT3D` is computed on, if `fft_length` is smaller than the
+corresponding dimension of `input`, the dimension is cropped. If it is larger,
+the dimension is padded with zeros.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RGBToHSV.pbtxt b/tensorflow/core/api_def/base_api/api_def_RGBToHSV.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..08629610ed4ba48e2a29e6294b9c7008359ff531
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RGBToHSV.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "RGBToHSV"
+  in_arg {
+    name: "images"
+    description: <<END
+1-D or higher rank. RGB data to convert. Last dimension must be size 3.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+`images` converted to HSV.
+END
+  }
+  summary: "Converts one or more images from RGB to HSV."
+  description: <<END
+Outputs a tensor of the same shape as the `images` tensor, containing the HSV
+value of the pixels. The output is only well defined if the value in `images`
+are in `[0,1]`.
+
+`output[..., 0]` contains hue, `output[..., 1]` contains saturation, and
+`output[..., 2]` contains value. All HSV values are in `[0,1]`. A hue of 0
+corresponds to pure red, hue 1/3 is pure green, and 2/3 is pure blue.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RandomCrop.pbtxt b/tensorflow/core/api_def/base_api/api_def_RandomCrop.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cd549dda14f7d7b1935e66f1ddf957bffe98c791
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RandomCrop.pbtxt
@@ -0,0 +1,44 @@
+op {
+  graph_op_name: "RandomCrop"
+  in_arg {
+    name: "image"
+    description: <<END
+3-D of shape `[height, width, channels]`.
+END
+  }
+  in_arg {
+    name: "size"
+    description: <<END
+1-D of length 2 containing: `crop_height`, `crop_width`..
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+3-D of shape `[crop_height, crop_width, channels].`
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either seed or seed2 are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+An second seed to avoid seed collision.
+END
+  }
+  summary: "Randomly crop `image`."
+  description: <<END
+`size` is a 1-D int64 tensor with 2 elements representing the crop height and
+width.  The values must be non negative.
+
+This Op picks a random location in `image` and crops a `height` by `width`
+rectangle from that location.  The random location is picked so the cropped
+area will fit inside the original image.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RandomGamma.pbtxt b/tensorflow/core/api_def/base_api/api_def_RandomGamma.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0a10392b6d24e94c35751c1c0881d1f7a6ea7ba8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RandomGamma.pbtxt
@@ -0,0 +1,45 @@
+op {
+  graph_op_name: "RandomGamma"
+  in_arg {
+    name: "shape"
+    description: <<END
+1-D integer tensor. Shape of independent samples to draw from each
+distribution described by the shape parameters given in alpha.
+END
+  }
+  in_arg {
+    name: "alpha"
+    description: <<END
+A tensor in which each scalar is a "shape" parameter describing the
+associated gamma distribution.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A tensor with shape `shape + shape(alpha)`. Each slice
+`[:, ..., :, i0, i1, ...iN]` contains the samples drawn for
+`alpha[i0, i1, ...iN]`. The dtype of the output matches the dtype of alpha.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either `seed` or `seed2` are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+A second seed to avoid seed collision.
+END
+  }
+  summary: "Outputs random values from the Gamma distribution(s) described by alpha."
+  description: <<END
+This op uses the algorithm by Marsaglia et al. to acquire samples via
+transformation-rejection from pairs of uniform and normal random variables.
+See http://dl.acm.org/citation.cfm?id=358414
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RandomPoisson.pbtxt b/tensorflow/core/api_def/base_api/api_def_RandomPoisson.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b75ecd2e1938fa13cd86e70370a4246887a3aef5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RandomPoisson.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "RandomPoisson"
+  summary: "Use RandomPoissonV2 instead."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RandomPoissonV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_RandomPoissonV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3aa8c30294963976db191641deb0781e82278164
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RandomPoissonV2.pbtxt
@@ -0,0 +1,51 @@
+op {
+  graph_op_name: "RandomPoissonV2"
+  in_arg {
+    name: "shape"
+    description: <<END
+1-D integer tensor. Shape of independent samples to draw from each
+distribution described by the shape parameters given in rate.
+END
+  }
+  in_arg {
+    name: "rate"
+    description: <<END
+A tensor in which each scalar is a "rate" parameter describing the
+associated poisson distribution.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A tensor with shape `shape + shape(rate)`. Each slice
+`[:, ..., :, i0, i1, ...iN]` contains the samples drawn for
+`rate[i0, i1, ...iN]`.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either `seed` or `seed2` are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+A second seed to avoid seed collision.
+END
+  }
+  summary: "Outputs random values from the Poisson distribution(s) described by rate."
+  description: <<END
+This op uses two algorithms, depending on rate. If rate >= 10, then
+the algorithm by Hormann is used to acquire samples via
+transformation-rejection.
+See http://www.sciencedirect.com/science/article/pii/0167668793909974.
+
+Otherwise, Knuth's algorithm is used to acquire samples via multiplying uniform
+random variables.
+See Donald E. Knuth (1969). Seminumerical Algorithms. The Art of Computer
+Programming, Volume 2. Addison Wesley
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RandomShuffle.pbtxt b/tensorflow/core/api_def/base_api/api_def_RandomShuffle.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7490361712f87c759145b0f01c1c8c3a5b273ad6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RandomShuffle.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "RandomShuffle"
+  in_arg {
+    name: "value"
+    description: <<END
+The tensor to be shuffled.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A tensor of same shape and type as `value`, shuffled along its first
+dimension.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either `seed` or `seed2` are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+A second seed to avoid seed collision.
+END
+  }
+  summary: "Randomly shuffles a tensor along its first dimension."
+  description: <<END
+  The tensor is shuffled along dimension 0, such that each `value[j]` is mapped
+  to one and only one `output[i]`. For example, a mapping that might occur for a
+  3x2 tensor is:
+
+```
+[[1, 2],       [[5, 6],
+ [3, 4],  ==>   [1, 2],
+ [5, 6]]        [3, 4]]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RandomShuffleQueue.pbtxt b/tensorflow/core/api_def/base_api/api_def_RandomShuffleQueue.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..258ef00b5c9cad94517b8e8a113dcb047aaeebed
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RandomShuffleQueue.pbtxt
@@ -0,0 +1,68 @@
+op {
+  graph_op_name: "RandomShuffleQueue"
+  visibility: SKIP
+  out_arg {
+    name: "handle"
+    description: <<END
+The handle to the queue.
+END
+  }
+  attr {
+    name: "component_types"
+    description: <<END
+The type of each component in a value.
+END
+  }
+  attr {
+    name: "shapes"
+    description: <<END
+The shape of each component in a value. The length of this attr must
+be either 0 or the same as the length of component_types. If the length of
+this attr is 0, the shapes of queue elements are not constrained, and
+only one element may be dequeued at a time.
+END
+  }
+  attr {
+    name: "capacity"
+    description: <<END
+The upper bound on the number of elements in this queue.
+Negative numbers mean no limit.
+END
+  }
+  attr {
+    name: "min_after_dequeue"
+    description: <<END
+Dequeue will block unless there would be this
+many elements after the dequeue or the queue is closed. This
+ensures a minimum level of mixing of elements.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either seed or seed2 is set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, a random seed is used.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+A second seed to avoid seed collision.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this queue is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this queue will be shared under the given name
+across multiple sessions.
+END
+  }
+  summary: "A queue that randomizes the order of elements."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RandomShuffleQueueV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_RandomShuffleQueueV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bb5a0fb8ede0653ee4db782aa3476fd1ba03a6e8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RandomShuffleQueueV2.pbtxt
@@ -0,0 +1,70 @@
+op {
+  graph_op_name: "RandomShuffleQueueV2"
+  endpoint {
+    name: "RandomShuffleQueue"
+  }
+  out_arg {
+    name: "handle"
+    description: <<END
+The handle to the queue.
+END
+  }
+  attr {
+    name: "component_types"
+    description: <<END
+The type of each component in a value.
+END
+  }
+  attr {
+    name: "shapes"
+    description: <<END
+The shape of each component in a value. The length of this attr must
+be either 0 or the same as the length of component_types. If the length of
+this attr is 0, the shapes of queue elements are not constrained, and
+only one element may be dequeued at a time.
+END
+  }
+  attr {
+    name: "capacity"
+    description: <<END
+The upper bound on the number of elements in this queue.
+Negative numbers mean no limit.
+END
+  }
+  attr {
+    name: "min_after_dequeue"
+    description: <<END
+Dequeue will block unless there would be this
+many elements after the dequeue or the queue is closed. This
+ensures a minimum level of mixing of elements.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either seed or seed2 is set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, a random seed is used.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+A second seed to avoid seed collision.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this queue is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this queue will be shared under the given name
+across multiple sessions.
+END
+  }
+  summary: "A queue that randomizes the order of elements."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RandomStandardNormal.pbtxt b/tensorflow/core/api_def/base_api/api_def_RandomStandardNormal.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d534785b14202fa7f0dbb28077b10a3846c5cce9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RandomStandardNormal.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "RandomStandardNormal"
+  endpoint {
+    name: "RandomNormal"
+  }
+  in_arg {
+    name: "shape"
+    description: <<END
+The shape of the output tensor.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A tensor of the specified shape filled with random normal values.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either `seed` or `seed2` are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+A second seed to avoid seed collision.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of the output.
+END
+  }
+  summary: "Outputs random values from a normal distribution."
+  description: <<END
+The generated values will have mean 0 and standard deviation 1.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RandomUniform.pbtxt b/tensorflow/core/api_def/base_api/api_def_RandomUniform.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..148a5b1c9aa40180ae8cce7e26deb5acbca9fd30
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RandomUniform.pbtxt
@@ -0,0 +1,40 @@
+op {
+  graph_op_name: "RandomUniform"
+  in_arg {
+    name: "shape"
+    description: <<END
+The shape of the output tensor.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A tensor of the specified shape filled with uniform random values.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either `seed` or `seed2` are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+A second seed to avoid seed collision.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of the output.
+END
+  }
+  summary: "Outputs random values from a uniform distribution."
+  description: <<END
+The generated values follow a uniform distribution in the range `[0, 1)`. The
+lower bound 0 is included in the range, while the upper bound 1 is excluded.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RandomUniformInt.pbtxt b/tensorflow/core/api_def/base_api/api_def_RandomUniformInt.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..76a8f4b3e43b6874d43de24cd8feda1244ffa0f5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RandomUniformInt.pbtxt
@@ -0,0 +1,51 @@
+op {
+  graph_op_name: "RandomUniformInt"
+  in_arg {
+    name: "shape"
+    description: <<END
+The shape of the output tensor.
+END
+  }
+  in_arg {
+    name: "minval"
+    description: <<END
+0-D.  Inclusive lower bound on the generated integers.
+END
+  }
+  in_arg {
+    name: "maxval"
+    description: <<END
+0-D.  Exclusive upper bound on the generated integers.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A tensor of the specified shape filled with uniform random integers.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either `seed` or `seed2` are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+A second seed to avoid seed collision.
+END
+  }
+  summary: "Outputs random integers from a uniform distribution."
+  description: <<END
+The generated values are uniform integers in the range `[minval, maxval)`.
+The lower bound `minval` is included in the range, while the upper bound
+`maxval` is excluded.
+
+The random integers are slightly biased unless `maxval - minval` is an exact
+power of two.  The bias is small for values of `maxval - minval` significantly
+smaller than the range of the output (either `2^32` or `2^64`).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Range.pbtxt b/tensorflow/core/api_def/base_api/api_def_Range.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cf1021ccfbf6e2b7460be89352a225ac72a96362
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Range.pbtxt
@@ -0,0 +1,41 @@
+op {
+  graph_op_name: "Range"
+  in_arg {
+    name: "start"
+    description: <<END
+0-D (scalar). First entry in the sequence.
+END
+  }
+  in_arg {
+    name: "limit"
+    description: <<END
+0-D (scalar). Upper limit of sequence, exclusive.
+END
+  }
+  in_arg {
+    name: "delta"
+    description: <<END
+0-D (scalar). Optional. Default is 1. Number that increments `start`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+1-D.
+END
+  }
+  summary: "Creates a sequence of numbers."
+  description: <<END
+This operation creates a sequence of numbers that begins at `start` and
+extends by increments of `delta` up to but not including `limit`.
+
+For example:
+
+```
+# 'start' is 3
+# 'limit' is 18
+# 'delta' is 3
+tf.range(start, limit, delta) ==> [3, 6, 9, 12, 15]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RangeDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_RangeDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a9e14b8a052e416dd78f1abdc25c9b024a778107
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RangeDataset.pbtxt
@@ -0,0 +1,22 @@
+op {
+  graph_op_name: "RangeDataset"
+  in_arg {
+    name: "start"
+    description: <<END
+corresponds to start in python's xrange().
+END
+  }
+  in_arg {
+    name: "stop"
+    description: <<END
+corresponds to stop in python's xrange().
+END
+  }
+  in_arg {
+    name: "step"
+    description: <<END
+corresponds to step in python's xrange().
+END
+  }
+  summary: "Creates a dataset with a range of values. Corresponds to python\'s xrange."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Rank.pbtxt b/tensorflow/core/api_def/base_api/api_def_Rank.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ec1c61671dee4f673cd808a79ba8a47f44e3f7bd
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Rank.pbtxt
@@ -0,0 +1,19 @@
+op {
+  graph_op_name: "Rank"
+  summary: "Returns the rank of a tensor."
+  description: <<END
+This operation returns an integer representing the rank of `input`.
+
+For example:
+
+```
+# 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
+# shape of tensor 't' is [2, 2, 3]
+rank(t) ==> 3
+```
+
+**Note**: The rank of a tensor is not the same as the rank of a matrix. The rank
+of a tensor is the number of indices required to uniquely select each element
+of the tensor. Rank is also known as "order", "degree", or "ndims."
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReadFile.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReadFile.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6161453d47647456c3b46aa8ac9ece549d7ad6bc
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReadFile.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ReadFile"
+  summary: "Reads and outputs the entire contents of the input filename."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReadVariableOp.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReadVariableOp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..eaa41b462cfaf95f7fdc92bb72733830a1165d9b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReadVariableOp.pbtxt
@@ -0,0 +1,24 @@
+op {
+  graph_op_name: "ReadVariableOp"
+  in_arg {
+    name: "resource"
+    description: <<END
+handle to the resource in which to store the variable.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+the dtype of the value.
+END
+  }
+  summary: "Reads the value of a variable."
+  description: <<END
+The tensor returned by this operation is immutable.
+
+The value returned by this operation is guaranteed to be influenced by all the
+writes on which this operation depends directly or indirectly, and to not be
+influenced by any of the writes which depend directly or indirectly on this
+operation.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReaderNumRecordsProduced.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReaderNumRecordsProduced.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..27c74890f2e696a235ba10bbc995037c17cb6cbc
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReaderNumRecordsProduced.pbtxt
@@ -0,0 +1,15 @@
+op {
+  graph_op_name: "ReaderNumRecordsProduced"
+  visibility: SKIP
+  in_arg {
+    name: "reader_handle"
+    description: <<END
+Handle to a Reader.
+END
+  }
+  summary: "Returns the number of records this Reader has produced."
+  description: <<END
+This is the same as the number of ReaderRead executions that have
+succeeded.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReaderNumRecordsProducedV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReaderNumRecordsProducedV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..caf4f6b90364b88ef4a212a9c9c095361b58d6ea
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReaderNumRecordsProducedV2.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "ReaderNumRecordsProducedV2"
+  endpoint {
+    name: "ReaderNumRecordsProduced"
+  }
+  in_arg {
+    name: "reader_handle"
+    description: <<END
+Handle to a Reader.
+END
+  }
+  summary: "Returns the number of records this Reader has produced."
+  description: <<END
+This is the same as the number of ReaderRead executions that have
+succeeded.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReaderNumWorkUnitsCompleted.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReaderNumWorkUnitsCompleted.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ba9143534d62522ddf57690d0b6691908be7dd6b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReaderNumWorkUnitsCompleted.pbtxt
@@ -0,0 +1,11 @@
+op {
+  graph_op_name: "ReaderNumWorkUnitsCompleted"
+  visibility: SKIP
+  in_arg {
+    name: "reader_handle"
+    description: <<END
+Handle to a Reader.
+END
+  }
+  summary: "Returns the number of work units this Reader has finished processing."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReaderNumWorkUnitsCompletedV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReaderNumWorkUnitsCompletedV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5289c84240d3746b8163b4fda2f4f79666dc0d11
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReaderNumWorkUnitsCompletedV2.pbtxt
@@ -0,0 +1,13 @@
+op {
+  graph_op_name: "ReaderNumWorkUnitsCompletedV2"
+  endpoint {
+    name: "ReaderNumWorkUnitsCompleted"
+  }
+  in_arg {
+    name: "reader_handle"
+    description: <<END
+Handle to a Reader.
+END
+  }
+  summary: "Returns the number of work units this Reader has finished processing."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReaderRead.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReaderRead.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..624b1c7fade5e9e311b81ff60740539cc7027181
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReaderRead.pbtxt
@@ -0,0 +1,34 @@
+op {
+  graph_op_name: "ReaderRead"
+  visibility: SKIP
+  in_arg {
+    name: "reader_handle"
+    description: <<END
+Handle to a Reader.
+END
+  }
+  in_arg {
+    name: "queue_handle"
+    description: <<END
+Handle to a Queue, with string work items.
+END
+  }
+  out_arg {
+    name: "key"
+    description: <<END
+A scalar.
+END
+  }
+  out_arg {
+    name: "value"
+    description: <<END
+A scalar.
+END
+  }
+  summary: "Returns the next record (key, value pair) produced by a Reader."
+  description: <<END
+Will dequeue from the input queue if necessary (e.g. when the
+Reader needs to start reading from a new file since it has finished
+with the previous file).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReaderReadUpTo.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReaderReadUpTo.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..53e6e44838c1fc91c66d26545ef58367db02bae3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReaderReadUpTo.pbtxt
@@ -0,0 +1,41 @@
+op {
+  graph_op_name: "ReaderReadUpTo"
+  visibility: SKIP
+  in_arg {
+    name: "reader_handle"
+    description: <<END
+Handle to a `Reader`.
+END
+  }
+  in_arg {
+    name: "queue_handle"
+    description: <<END
+Handle to a `Queue`, with string work items.
+END
+  }
+  in_arg {
+    name: "num_records"
+    description: <<END
+number of records to read from `Reader`.
+END
+  }
+  out_arg {
+    name: "keys"
+    description: <<END
+A 1-D tensor.
+END
+  }
+  out_arg {
+    name: "values"
+    description: <<END
+A 1-D tensor.
+END
+  }
+  summary: "Returns up to `num_records` (key, value) pairs produced by a Reader."
+  description: <<END
+Will dequeue from the input queue if necessary (e.g. when the
+Reader needs to start reading from a new file since it has finished
+with the previous file).
+It may return less than `num_records` even before the last batch.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReaderReadUpToV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReaderReadUpToV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c1d2206ffe1730a9a9d75e1409148bf830f522e2
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReaderReadUpToV2.pbtxt
@@ -0,0 +1,43 @@
+op {
+  graph_op_name: "ReaderReadUpToV2"
+  endpoint {
+    name: "ReaderReadUpTo"
+  }
+  in_arg {
+    name: "reader_handle"
+    description: <<END
+Handle to a `Reader`.
+END
+  }
+  in_arg {
+    name: "queue_handle"
+    description: <<END
+Handle to a `Queue`, with string work items.
+END
+  }
+  in_arg {
+    name: "num_records"
+    description: <<END
+number of records to read from `Reader`.
+END
+  }
+  out_arg {
+    name: "keys"
+    description: <<END
+A 1-D tensor.
+END
+  }
+  out_arg {
+    name: "values"
+    description: <<END
+A 1-D tensor.
+END
+  }
+  summary: "Returns up to `num_records` (key, value) pairs produced by a Reader."
+  description: <<END
+Will dequeue from the input queue if necessary (e.g. when the
+Reader needs to start reading from a new file since it has finished
+with the previous file).
+It may return less than `num_records` even before the last batch.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReaderReadV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReaderReadV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6a6c4efdf5b16fb8dd0a01bfc66dfd825c589924
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReaderReadV2.pbtxt
@@ -0,0 +1,36 @@
+op {
+  graph_op_name: "ReaderReadV2"
+  endpoint {
+    name: "ReaderRead"
+  }
+  in_arg {
+    name: "reader_handle"
+    description: <<END
+Handle to a Reader.
+END
+  }
+  in_arg {
+    name: "queue_handle"
+    description: <<END
+Handle to a Queue, with string work items.
+END
+  }
+  out_arg {
+    name: "key"
+    description: <<END
+A scalar.
+END
+  }
+  out_arg {
+    name: "value"
+    description: <<END
+A scalar.
+END
+  }
+  summary: "Returns the next record (key, value pair) produced by a Reader."
+  description: <<END
+Will dequeue from the input queue if necessary (e.g. when the
+Reader needs to start reading from a new file since it has finished
+with the previous file).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReaderReset.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReaderReset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1ddb494293e4fc567e3d742162c78607b9c0a09d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReaderReset.pbtxt
@@ -0,0 +1,11 @@
+op {
+  graph_op_name: "ReaderReset"
+  visibility: SKIP
+  in_arg {
+    name: "reader_handle"
+    description: <<END
+Handle to a Reader.
+END
+  }
+  summary: "Restore a Reader to its initial clean state."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReaderResetV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReaderResetV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6ac5b77d271eeee3f6bcdbb637b73e2f869d0f54
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReaderResetV2.pbtxt
@@ -0,0 +1,13 @@
+op {
+  graph_op_name: "ReaderResetV2"
+  endpoint {
+    name: "ReaderReset"
+  }
+  in_arg {
+    name: "reader_handle"
+    description: <<END
+Handle to a Reader.
+END
+  }
+  summary: "Restore a Reader to its initial clean state."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReaderRestoreState.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReaderRestoreState.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..05084ba367205e8e4657bec432e8fbd103faca9f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReaderRestoreState.pbtxt
@@ -0,0 +1,22 @@
+op {
+  graph_op_name: "ReaderRestoreState"
+  visibility: SKIP
+  in_arg {
+    name: "reader_handle"
+    description: <<END
+Handle to a Reader.
+END
+  }
+  in_arg {
+    name: "state"
+    description: <<END
+Result of a ReaderSerializeState of a Reader with type
+matching reader_handle.
+END
+  }
+  summary: "Restore a reader to a previously saved state."
+  description: <<END
+Not all Readers support being restored, so this can produce an
+Unimplemented error.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReaderRestoreStateV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReaderRestoreStateV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..35e053d0ea21a66893e3a6e55c33604a84da4761
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReaderRestoreStateV2.pbtxt
@@ -0,0 +1,24 @@
+op {
+  graph_op_name: "ReaderRestoreStateV2"
+  endpoint {
+    name: "ReaderRestoreState"
+  }
+  in_arg {
+    name: "reader_handle"
+    description: <<END
+Handle to a Reader.
+END
+  }
+  in_arg {
+    name: "state"
+    description: <<END
+Result of a ReaderSerializeState of a Reader with type
+matching reader_handle.
+END
+  }
+  summary: "Restore a reader to a previously saved state."
+  description: <<END
+Not all Readers support being restored, so this can produce an
+Unimplemented error.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReaderSerializeState.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReaderSerializeState.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..401c22abd0db6fe1e1e6d07f78915ab7ecd0e64d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReaderSerializeState.pbtxt
@@ -0,0 +1,15 @@
+op {
+  graph_op_name: "ReaderSerializeState"
+  visibility: SKIP
+  in_arg {
+    name: "reader_handle"
+    description: <<END
+Handle to a Reader.
+END
+  }
+  summary: "Produce a string tensor that encodes the state of a Reader."
+  description: <<END
+Not all Readers support being serialized, so this can produce an
+Unimplemented error.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReaderSerializeStateV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReaderSerializeStateV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..855ba3c2eed02af1aed3aaf36410e5d9c23e4cb5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReaderSerializeStateV2.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "ReaderSerializeStateV2"
+  endpoint {
+    name: "ReaderSerializeState"
+  }
+  in_arg {
+    name: "reader_handle"
+    description: <<END
+Handle to a Reader.
+END
+  }
+  summary: "Produce a string tensor that encodes the state of a Reader."
+  description: <<END
+Not all Readers support being serialized, so this can produce an
+Unimplemented error.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Real.pbtxt b/tensorflow/core/api_def/base_api/api_def_Real.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..225d45fd70ea90247d11c44e81a9cba655de5717
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Real.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "Real"
+  summary: "Returns the real part of a complex number."
+  description: <<END
+Given a tensor `input` of complex numbers, this operation returns a tensor of
+type `float` that is the real part of each element in `input`. All elements in
+`input` must be complex numbers of the form \\(a + bj\\), where *a* is the real
+ part returned by this operation and *b* is the imaginary part.
+
+For example:
+
+```
+# tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
+tf.real(input) ==> [-2.25, 3.25]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RealDiv.pbtxt b/tensorflow/core/api_def/base_api/api_def_RealDiv.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..da0e55b08f56475b21d4f7a9ab82677011406092
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RealDiv.pbtxt
@@ -0,0 +1,10 @@
+op {
+  graph_op_name: "RealDiv"
+  summary: "Returns x / y element-wise for real types."
+  description: <<END
+If `x` and `y` are reals, this will return the floating-point division.
+
+*NOTE*: `Div` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Reciprocal.pbtxt b/tensorflow/core/api_def/base_api/api_def_Reciprocal.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c66b84e268c706bba28d34c69d42b599f179e367
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Reciprocal.pbtxt
@@ -0,0 +1,7 @@
+op {
+  graph_op_name: "Reciprocal"
+  summary: "Computes the reciprocal of x element-wise."
+  description: <<END
+I.e., \\(y = 1 / x\\).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReciprocalGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReciprocalGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..583e5ecee1fe8ff2e187fd909c09b2381f9bee74
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReciprocalGrad.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "ReciprocalGrad"
+  visibility: HIDDEN
+  summary: "Computes the gradient for the inverse of `x` wrt its input."
+  description: <<END
+Specifically, `grad = -dy * y*y`, where `y = 1/x`, and `dy`
+is the corresponding input gradient.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RecordInput.pbtxt b/tensorflow/core/api_def/base_api/api_def_RecordInput.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7efc8cd8334e80be3b1cc8ba5b50c2259931b1b6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RecordInput.pbtxt
@@ -0,0 +1,47 @@
+op {
+  graph_op_name: "RecordInput"
+  out_arg {
+    name: "records"
+    description: <<END
+A tensor of shape [batch_size].
+END
+  }
+  attr {
+    name: "file_pattern"
+    description: <<END
+Glob pattern for the data files.
+END
+  }
+  attr {
+    name: "file_random_seed"
+    description: <<END
+Random seeds used to produce randomized records.
+END
+  }
+  attr {
+    name: "file_shuffle_shift_ratio"
+    description: <<END
+Shifts the list of files after the list is randomly
+shuffled.
+END
+  }
+  attr {
+    name: "file_buffer_size"
+    description: <<END
+The randomization shuffling buffer.
+END
+  }
+  attr {
+    name: "file_parallelism"
+    description: <<END
+How many sstables are opened and concurrently iterated over.
+END
+  }
+  attr {
+    name: "batch_size"
+    description: <<END
+The batch size.
+END
+  }
+  summary: "Emits randomized records."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReduceJoin.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReduceJoin.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ca7e0d3beefa219a468135ec53b2564f0d0287c7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReduceJoin.pbtxt
@@ -0,0 +1,59 @@
+op {
+  graph_op_name: "ReduceJoin"
+  in_arg {
+    name: "inputs"
+    description: <<END
+The input to be joined.  All reduced indices must have non-zero size.
+END
+  }
+  in_arg {
+    name: "reduction_indices"
+    description: <<END
+The dimensions to reduce over.  Dimensions are reduced in the
+order specified.  Omitting `reduction_indices` is equivalent to passing
+`[n-1, n-2, ..., 0]`.  Negative indices from `-n` to `-1` are supported.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Has shape equal to that of the input with reduced dimensions removed or
+set to `1` depending on `keep_dims`.
+END
+  }
+  attr {
+    name: "keep_dims"
+    description: <<END
+If `True`, retain reduced dimensions with length `1`.
+END
+  }
+  attr {
+    name: "separator"
+    description: <<END
+The separator to use when joining.
+END
+  }
+  summary: "Joins a string Tensor across the given dimensions."
+  description: <<END
+Computes the string join across dimensions in the given string Tensor of shape
+`[d_0, d_1, ..., d_n-1]`.  Returns a new Tensor created by joining the input
+strings with the given separator (default: empty string).  Negative indices are
+counted backwards from the end, with `-1` being equivalent to `n - 1`.
+
+For example:
+
+```python
+# tensor `a` is [["a", "b"], ["c", "d"]]
+tf.reduce_join(a, 0) ==> ["ac", "bd"]
+tf.reduce_join(a, 1) ==> ["ab", "cd"]
+tf.reduce_join(a, -2) = tf.reduce_join(a, 0) ==> ["ac", "bd"]
+tf.reduce_join(a, -1) = tf.reduce_join(a, 1) ==> ["ab", "cd"]
+tf.reduce_join(a, 0, keep_dims=True) ==> [["ac", "bd"]]
+tf.reduce_join(a, 1, keep_dims=True) ==> [["ab"], ["cd"]]
+tf.reduce_join(a, 0, separator=".") ==> ["a.c", "b.d"]
+tf.reduce_join(a, [0, 1]) ==> ["acbd"]
+tf.reduce_join(a, [1, 0]) ==> ["abcd"]
+tf.reduce_join(a, []) ==> ["abcd"]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RefEnter.pbtxt b/tensorflow/core/api_def/base_api/api_def_RefEnter.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..092f285b270f7af74ae3a7e0b6797fc5d92d1895
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RefEnter.pbtxt
@@ -0,0 +1,41 @@
+op {
+  graph_op_name: "RefEnter"
+  visibility: HIDDEN
+  in_arg {
+    name: "data"
+    description: <<END
+The tensor to be made available to the child frame.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The same tensor as `data`.
+END
+  }
+  attr {
+    name: "frame_name"
+    description: <<END
+The name of the child frame.
+END
+  }
+  attr {
+    name: "is_constant"
+    description: <<END
+If true, the output is constant within the child frame.
+END
+  }
+  attr {
+    name: "parallel_iterations"
+    description: <<END
+The number of iterations allowed to run in parallel.
+END
+  }
+  summary: "Creates or finds a child frame, and makes `data` available to the child frame."
+  description: <<END
+The unique `frame_name` is used by the `Executor` to identify frames. If
+`is_constant` is true, `output` is a constant in the child frame; otherwise
+it may be changed in the child frame. At most `parallel_iterations` iterations
+are run in parallel in the child frame.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RefExit.pbtxt b/tensorflow/core/api_def/base_api/api_def_RefExit.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6d3083d6d98f16560e3dcd152e1d0c815c0b57f1
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RefExit.pbtxt
@@ -0,0 +1,20 @@
+op {
+  graph_op_name: "RefExit"
+  visibility: HIDDEN
+  in_arg {
+    name: "data"
+    description: <<END
+The tensor to be made available to the parent frame.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The same tensor as `data`.
+END
+  }
+  summary: "Exits the current frame to its parent frame."
+  description: <<END
+Exit makes its input `data` available to the parent frame.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RefIdentity.pbtxt b/tensorflow/core/api_def/base_api/api_def_RefIdentity.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b29606837edc3cae002bb762f7e48c2e306a733e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RefIdentity.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "RefIdentity"
+  visibility: HIDDEN
+  summary: "Return the same ref tensor as the input ref tensor."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RefMerge.pbtxt b/tensorflow/core/api_def/base_api/api_def_RefMerge.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cc7ad303c5812daa8119516b151cea4a37e21d77
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RefMerge.pbtxt
@@ -0,0 +1,30 @@
+op {
+  graph_op_name: "RefMerge"
+  visibility: HIDDEN
+  in_arg {
+    name: "inputs"
+    description: <<END
+The input tensors, exactly one of which will become available.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Will be set to the available input tensor.
+END
+  }
+  out_arg {
+    name: "value_index"
+    description: <<END
+The index of the chosen input tensor in `inputs`.
+END
+  }
+  summary: "Forwards the value of an available tensor from `inputs` to `output`."
+  description: <<END
+`Merge` waits for at least one of the tensors in `inputs` to become available.
+It is usually combined with `Switch` to implement branching.
+
+`Merge` forwards the first tensor for become available to `output`, and sets
+`value_index` to its index in `inputs`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RefNextIteration.pbtxt b/tensorflow/core/api_def/base_api/api_def_RefNextIteration.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fd126e99b85dd047ec84ec994ae00b4931b10bd3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RefNextIteration.pbtxt
@@ -0,0 +1,16 @@
+op {
+  graph_op_name: "RefNextIteration"
+  in_arg {
+    name: "data"
+    description: <<END
+The tensor to be made available to the next iteration.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The same tensor as `data`.
+END
+  }
+  summary: "Makes its input available to the next iteration."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RefSelect.pbtxt b/tensorflow/core/api_def/base_api/api_def_RefSelect.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..24a0c4684e76c9a61388ad566d97ef4bdf8c21be
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RefSelect.pbtxt
@@ -0,0 +1,22 @@
+op {
+  graph_op_name: "RefSelect"
+  in_arg {
+    name: "index"
+    description: <<END
+A scalar that determines the input that gets selected.
+END
+  }
+  in_arg {
+    name: "inputs"
+    description: <<END
+A list of ref tensors, one of which will be forwarded to `output`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The forwarded tensor.
+END
+  }
+  summary: "Forwards the `index`th element of `inputs` to `output`."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RefSwitch.pbtxt b/tensorflow/core/api_def/base_api/api_def_RefSwitch.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..11db13a17edb3b859241511a9fb81c88bbbbcac8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RefSwitch.pbtxt
@@ -0,0 +1,34 @@
+op {
+  graph_op_name: "RefSwitch"
+  in_arg {
+    name: "data"
+    description: <<END
+The ref tensor to be forwarded to the appropriate output.
+END
+  }
+  in_arg {
+    name: "pred"
+    description: <<END
+A scalar that specifies which output port will receive data.
+END
+  }
+  out_arg {
+    name: "output_false"
+    description: <<END
+If `pred` is false, data will be forwarded to this output.
+END
+  }
+  out_arg {
+    name: "output_true"
+    description: <<END
+If `pred` is true, data will be forwarded to this output.
+END
+  }
+  summary: "Forwards the ref tensor `data` to the output port determined by `pred`."
+  description: <<END
+If `pred` is true, the `data` input is forwarded to `output_true`. Otherwise,
+the data goes to `output_false`.
+
+See also `Switch` and `Merge`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Relu.pbtxt b/tensorflow/core/api_def/base_api/api_def_Relu.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..44f79b0e29a04cc53dded5052788e370644821fe
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Relu.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Relu"
+  summary: "Computes rectified linear: `max(features, 0)`."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Relu6.pbtxt b/tensorflow/core/api_def/base_api/api_def_Relu6.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..13a737394c0171cfd81bbf23fb85ac9b1de4b6f7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Relu6.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Relu6"
+  summary: "Computes rectified linear 6: `min(max(features, 0), 6)`."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Relu6Grad.pbtxt b/tensorflow/core/api_def/base_api/api_def_Relu6Grad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fc81506f66a09385f843790a7c2665e25082ca54
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Relu6Grad.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "Relu6Grad"
+  visibility: HIDDEN
+  in_arg {
+    name: "gradients"
+    description: <<END
+The backpropagated gradients to the corresponding Relu6 operation.
+END
+  }
+  in_arg {
+    name: "features"
+    description: <<END
+The features passed as input to the corresponding Relu6 operation, or
+its output; using either one produces the same result.
+END
+  }
+  out_arg {
+    name: "backprops"
+    description: <<END
+The gradients:
+`gradients * (features > 0) * (features < 6)`.
+END
+  }
+  summary: "Computes rectified linear 6 gradients for a Relu6 operation."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReluGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReluGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..94affbc3b71a52e7910477f4a33119ac7ceed6c8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReluGrad.pbtxt
@@ -0,0 +1,24 @@
+op {
+  graph_op_name: "ReluGrad"
+  visibility: HIDDEN
+  in_arg {
+    name: "gradients"
+    description: <<END
+The backpropagated gradients to the corresponding Relu operation.
+END
+  }
+  in_arg {
+    name: "features"
+    description: <<END
+The features passed as input to the corresponding Relu operation, OR
+the outputs of that operation (both work equivalently).
+END
+  }
+  out_arg {
+    name: "backprops"
+    description: <<END
+`gradients * (features > 0)`.
+END
+  }
+  summary: "Computes rectified linear gradients for a Relu operation."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RemoteCall.pbtxt b/tensorflow/core/api_def/base_api/api_def_RemoteCall.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1f75f32ebcc8820bf642f3066d1eb0d7fa61da3f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RemoteCall.pbtxt
@@ -0,0 +1,40 @@
+op {
+  graph_op_name: "RemoteCall"
+  in_arg {
+    name: "target"
+    description: <<END
+A fully specified device name where we want to run the function.
+END
+  }
+  in_arg {
+    name: "args"
+    description: <<END
+A list of arguments for the function.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A list of return values.
+END
+  }
+  attr {
+    name: "Tin"
+    description: <<END
+The type list for the arguments.
+END
+  }
+  attr {
+    name: "Tout"
+    description: <<END
+The type list for the return values.
+END
+  }
+  attr {
+    name: "f"
+    description: <<END
+The function to run remotely.
+END
+  }
+  summary: "Runs function `f` on a remote device indicated by `target`."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RemoteFusedGraphExecute.pbtxt b/tensorflow/core/api_def/base_api/api_def_RemoteFusedGraphExecute.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..190df5ecbbd01aa6a39f382e45d631e3224fa879
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RemoteFusedGraphExecute.pbtxt
@@ -0,0 +1,32 @@
+op {
+  graph_op_name: "RemoteFusedGraphExecute"
+  in_arg {
+    name: "inputs"
+    description: <<END
+Arbitrary number of tensors with arbitrary data types
+END
+  }
+  out_arg {
+    name: "outputs"
+    description: <<END
+Arbitrary number of tensors with arbitrary data types
+END
+  }
+  attr {
+    name: "serialized_remote_fused_graph_execute_info"
+    description: <<END
+Serialized protocol buffer
+of RemoteFusedGraphExecuteInfo which contains graph specifications.
+END
+  }
+  summary: "Execute a sub graph on a remote processor."
+  description: <<END
+The graph specifications(such as graph itself, input tensors and output names)
+are stored as a serialized protocol buffer of RemoteFusedGraphExecuteInfo
+as serialized_remote_fused_graph_execute_info.
+The specifications will be passed to a dedicated registered
+remote fused graph executor.  The executor will send the graph specifications
+to a remote processor and execute that graph.  The execution results
+will be passed to consumer nodes as outputs of this node.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RepeatDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_RepeatDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fc6169cd32f1671000a9cb96209059d062c00db8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RepeatDataset.pbtxt
@@ -0,0 +1,11 @@
+op {
+  graph_op_name: "RepeatDataset"
+  in_arg {
+    name: "count"
+    description: <<END
+A scalar representing the number of times that `input_dataset` should
+be repeated. A value of `-1` indicates that it should be repeated infinitely.
+END
+  }
+  summary: "Creates a dataset that emits the outputs of `input_dataset` `count` times."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RequantizationRange.pbtxt b/tensorflow/core/api_def/base_api/api_def_RequantizationRange.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..07bbd4ac6031765a070c5e5b4ee0726512dbb6ca
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RequantizationRange.pbtxt
@@ -0,0 +1,39 @@
+op {
+  graph_op_name: "RequantizationRange"
+  in_arg {
+    name: "input_min"
+    description: <<END
+The float value that the minimum quantized input value represents.
+END
+  }
+  in_arg {
+    name: "input_max"
+    description: <<END
+The float value that the maximum quantized input value represents.
+END
+  }
+  out_arg {
+    name: "output_min"
+    description: <<END
+The computed min output.
+END
+  }
+  out_arg {
+    name: "output_max"
+    description: <<END
+the computed max output.
+END
+  }
+  attr {
+    name: "Tinput"
+    description: <<END
+The type of the input.
+END
+  }
+  summary: "Given a quantized tensor described by (input, input_min, input_max), outputs a"
+  description: <<END
+range that covers the actual values present in that tensor.  This op is
+typically used to produce the requested_output_min and requested_output_max for
+Requantize.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Requantize.pbtxt b/tensorflow/core/api_def/base_api/api_def_Requantize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1b03f63b261e00c6b1dfdc0b1f11c69d71b536eb
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Requantize.pbtxt
@@ -0,0 +1,60 @@
+op {
+  graph_op_name: "Requantize"
+  in_arg {
+    name: "input_min"
+    description: <<END
+The float value that the minimum quantized input value represents.
+END
+  }
+  in_arg {
+    name: "input_max"
+    description: <<END
+The float value that the maximum quantized input value represents.
+END
+  }
+  in_arg {
+    name: "requested_output_min"
+    description: <<END
+The float value that the minimum quantized output value represents.
+END
+  }
+  in_arg {
+    name: "requested_output_max"
+    description: <<END
+The float value that the maximum quantized output value represents.
+END
+  }
+  out_arg {
+    name: "output_min"
+    description: <<END
+The requested_output_min value is copied into this output.
+END
+  }
+  out_arg {
+    name: "output_max"
+    description: <<END
+The requested_output_max value is copied into this output.
+END
+  }
+  attr {
+    name: "Tinput"
+    description: <<END
+The type of the input.
+END
+  }
+  attr {
+    name: "out_type"
+    description: <<END
+The type of the output. Should be a lower bit depth than Tinput.
+END
+  }
+  summary: "Convert the quantized \'input\' tensor into a lower-precision \'output\', using the"
+  description: <<END
+output range specified with 'requested_output_min' and 'requested_output_max'.
+
+[input_min, input_max] are scalar floats that specify the range for the float
+interpretation of the 'input' data. For example, if input_min is -1.0f and
+input_max is 1.0f, and we are dealing with quint16 quantized data, then a 0
+value in the 16-bit data should be interpreted as -1.0f, and a 65535 means 1.0f.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Reshape.pbtxt b/tensorflow/core/api_def/base_api/api_def_Reshape.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fa32b2537450271cc53f8bd90bd92a7c6570af10
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Reshape.pbtxt
@@ -0,0 +1,68 @@
+op {
+  graph_op_name: "Reshape"
+  in_arg {
+    name: "shape"
+    description: <<END
+Defines the shape of the output tensor.
+END
+  }
+  summary: "Reshapes a tensor."
+  description: <<END
+Given `tensor`, this operation returns a tensor that has the same values
+as `tensor` with shape `shape`.
+
+If one component of `shape` is the special value -1, the size of that dimension
+is computed so that the total size remains constant.  In particular, a `shape`
+of `[-1]` flattens into 1-D.  At most one component of `shape` can be -1.
+
+If `shape` is 1-D or higher, then the operation returns a tensor with shape
+`shape` filled with the values of `tensor`. In this case, the number of elements
+implied by `shape` must be the same as the number of elements in `tensor`.
+
+For example:
+
+```
+# tensor 't' is [1, 2, 3, 4, 5, 6, 7, 8, 9]
+# tensor 't' has shape [9]
+reshape(t, [3, 3]) ==> [[1, 2, 3],
+                        [4, 5, 6],
+                        [7, 8, 9]]
+
+# tensor 't' is [[[1, 1], [2, 2]],
+#                [[3, 3], [4, 4]]]
+# tensor 't' has shape [2, 2, 2]
+reshape(t, [2, 4]) ==> [[1, 1, 2, 2],
+                        [3, 3, 4, 4]]
+
+# tensor 't' is [[[1, 1, 1],
+#                 [2, 2, 2]],
+#                [[3, 3, 3],
+#                 [4, 4, 4]],
+#                [[5, 5, 5],
+#                 [6, 6, 6]]]
+# tensor 't' has shape [3, 2, 3]
+# pass '[-1]' to flatten 't'
+reshape(t, [-1]) ==> [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6]
+
+# -1 can also be used to infer the shape
+
+# -1 is inferred to be 9:
+reshape(t, [2, -1]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3],
+                         [4, 4, 4, 5, 5, 5, 6, 6, 6]]
+# -1 is inferred to be 2:
+reshape(t, [-1, 9]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3],
+                         [4, 4, 4, 5, 5, 5, 6, 6, 6]]
+# -1 is inferred to be 3:
+reshape(t, [ 2, -1, 3]) ==> [[[1, 1, 1],
+                              [2, 2, 2],
+                              [3, 3, 3]],
+                             [[4, 4, 4],
+                              [5, 5, 5],
+                              [6, 6, 6]]]
+
+# tensor 't' is [7]
+# shape `[]` reshapes to a scalar
+reshape(t, []) ==> 7
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResizeArea.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResizeArea.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6dc321a54496ea3f91b7efe0d28c8596cd18fc1c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResizeArea.pbtxt
@@ -0,0 +1,40 @@
+op {
+  graph_op_name: "ResizeArea"
+  in_arg {
+    name: "images"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.
+END
+  }
+  in_arg {
+    name: "size"
+    description: <<END
+= A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+new size for the images.
+END
+  }
+  out_arg {
+    name: "resized_images"
+    description: <<END
+4-D with shape
+`[batch, new_height, new_width, channels]`.
+END
+  }
+  attr {
+    name: "align_corners"
+    description: <<END
+If true, rescale input by (new_height - 1) / (height - 1), which
+exactly aligns the 4 corners of images and resized images. If false, rescale
+by new_height / height. Treat similarly the width dimension.
+END
+  }
+  summary: "Resize `images` to `size` using area interpolation."
+  description: <<END
+Input images can be of different types but output images are always float.
+
+Each output pixel is computed by first transforming the pixel's footprint into
+the input tensor and then averaging the pixels that intersect the footprint. An
+input pixel's contribution to the average is weighted by the fraction of its
+area that intersects the footprint.  This is the same as OpenCV's INTER_AREA.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResizeBicubic.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResizeBicubic.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..06e645e3ee937f81e3b546d24250f1c1d6ad2680
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResizeBicubic.pbtxt
@@ -0,0 +1,35 @@
+op {
+  graph_op_name: "ResizeBicubic"
+  in_arg {
+    name: "images"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.
+END
+  }
+  in_arg {
+    name: "size"
+    description: <<END
+= A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+new size for the images.
+END
+  }
+  out_arg {
+    name: "resized_images"
+    description: <<END
+4-D with shape
+`[batch, new_height, new_width, channels]`.
+END
+  }
+  attr {
+    name: "align_corners"
+    description: <<END
+If true, rescale input by (new_height - 1) / (height - 1), which
+exactly aligns the 4 corners of images and resized images. If false, rescale
+by new_height / height. Treat similarly the width dimension.
+END
+  }
+  summary: "Resize `images` to `size` using bicubic interpolation."
+  description: <<END
+Input images can be of different types but output images are always float.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResizeBicubicGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResizeBicubicGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bf5201d82e4b7b6fb463e17138e92f3033c6992e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResizeBicubicGrad.pbtxt
@@ -0,0 +1,34 @@
+op {
+  graph_op_name: "ResizeBicubicGrad"
+  visibility: HIDDEN
+  in_arg {
+    name: "grads"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.
+END
+  }
+  in_arg {
+    name: "original_image"
+    description: <<END
+4-D with shape `[batch, orig_height, orig_width, channels]`,
+The image tensor that was resized.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+4-D with shape `[batch, orig_height, orig_width, channels]`.
+Gradients with respect to the input image. Input image must have been
+float or double.
+END
+  }
+  attr {
+    name: "align_corners"
+    description: <<END
+If true, rescale grads by (orig_height - 1) / (height - 1), which
+exactly aligns the 4 corners of grads and original_image. If false, rescale by
+orig_height / height. Treat similarly the width dimension.
+END
+  }
+  summary: "Computes the gradient of bicubic interpolation."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResizeBilinear.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResizeBilinear.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0768e437fa00a9adeec00498e968986125602822
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResizeBilinear.pbtxt
@@ -0,0 +1,35 @@
+op {
+  graph_op_name: "ResizeBilinear"
+  in_arg {
+    name: "images"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.
+END
+  }
+  in_arg {
+    name: "size"
+    description: <<END
+= A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+new size for the images.
+END
+  }
+  out_arg {
+    name: "resized_images"
+    description: <<END
+4-D with shape
+`[batch, new_height, new_width, channels]`.
+END
+  }
+  attr {
+    name: "align_corners"
+    description: <<END
+If true, rescale input by (new_height - 1) / (height - 1), which
+exactly aligns the 4 corners of images and resized images. If false, rescale
+by new_height / height. Treat similarly the width dimension.
+END
+  }
+  summary: "Resize `images` to `size` using bilinear interpolation."
+  description: <<END
+Input images can be of different types but output images are always float.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResizeBilinearGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResizeBilinearGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fba64203c236399e79a051206e936ec3ebb27b14
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResizeBilinearGrad.pbtxt
@@ -0,0 +1,34 @@
+op {
+  graph_op_name: "ResizeBilinearGrad"
+  visibility: HIDDEN
+  in_arg {
+    name: "grads"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.
+END
+  }
+  in_arg {
+    name: "original_image"
+    description: <<END
+4-D with shape `[batch, orig_height, orig_width, channels]`,
+The image tensor that was resized.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+4-D with shape `[batch, orig_height, orig_width, channels]`.
+Gradients with respect to the input image. Input image must have been
+float or double.
+END
+  }
+  attr {
+    name: "align_corners"
+    description: <<END
+If true, rescale grads by (orig_height - 1) / (height - 1), which
+exactly aligns the 4 corners of grads and original_image. If false, rescale by
+orig_height / height. Treat similarly the width dimension.
+END
+  }
+  summary: "Computes the gradient of bilinear interpolation."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResizeNearestNeighbor.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResizeNearestNeighbor.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a74db4c9dc340b90817567751da110ef8989850f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResizeNearestNeighbor.pbtxt
@@ -0,0 +1,32 @@
+op {
+  graph_op_name: "ResizeNearestNeighbor"
+  in_arg {
+    name: "images"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.
+END
+  }
+  in_arg {
+    name: "size"
+    description: <<END
+= A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+new size for the images.
+END
+  }
+  out_arg {
+    name: "resized_images"
+    description: <<END
+4-D with shape
+`[batch, new_height, new_width, channels]`.
+END
+  }
+  attr {
+    name: "align_corners"
+    description: <<END
+If true, rescale input by (new_height - 1) / (height - 1), which
+exactly aligns the 4 corners of images and resized images. If false, rescale
+by new_height / height. Treat similarly the width dimension.
+END
+  }
+  summary: "Resize `images` to `size` using nearest neighbor interpolation."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResizeNearestNeighborGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResizeNearestNeighborGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4ef1547eb4fab02392bc2b98a21ef01340b621f3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResizeNearestNeighborGrad.pbtxt
@@ -0,0 +1,33 @@
+op {
+  graph_op_name: "ResizeNearestNeighborGrad"
+  visibility: HIDDEN
+  in_arg {
+    name: "grads"
+    description: <<END
+4-D with shape `[batch, height, width, channels]`.
+END
+  }
+  in_arg {
+    name: "size"
+    description: <<END
+= A 1-D int32 Tensor of 2 elements: `orig_height, orig_width`. The
+original input size.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+4-D with shape `[batch, orig_height, orig_width, channels]`. Gradients
+with respect to the input image.
+END
+  }
+  attr {
+    name: "align_corners"
+    description: <<END
+If true, rescale grads by (orig_height - 1) / (height - 1), which
+exactly aligns the 4 corners of grads and original_image. If false, rescale by
+orig_height / height. Treat similarly the width dimension.
+END
+  }
+  summary: "Computes the gradient of nearest neighbor interpolation."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceApplyAdadelta.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceApplyAdadelta.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f2708a8348846b87daad5bc9039e0a70755c83b4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceApplyAdadelta.pbtxt
@@ -0,0 +1,59 @@
+op {
+  graph_op_name: "ResourceApplyAdadelta"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum_update"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "rho"
+    description: <<END
+Decay factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "epsilon"
+    description: <<END
+Constant factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, updating of the var, accum and update_accum tensors will be protected by
+a lock; otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Update \'*var\' according to the adadelta scheme."
+  description: <<END
+accum = rho() * accum + (1 - rho()) * grad.square();
+update = (update_accum + epsilon).sqrt() * (accum + epsilon()).rsqrt() * grad;
+update_accum = rho() * update_accum + (1 - rho()) * update.square();
+var -= update;
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceApplyAdagrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceApplyAdagrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5982d4d371af48ea757f4733bece2e853538d18a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceApplyAdagrad.pbtxt
@@ -0,0 +1,40 @@
+op {
+  graph_op_name: "ResourceApplyAdagrad"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var and accum tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update \'*var\' according to the adagrad scheme."
+  description: <<END
+accum += grad * grad
+var -= lr * grad * (1 / sqrt(accum))
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceApplyAdagradDA.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceApplyAdagradDA.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..254e0c609ad061fc2273036edc413af2f9dcc4e7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceApplyAdagradDA.pbtxt
@@ -0,0 +1,59 @@
+op {
+  graph_op_name: "ResourceApplyAdagradDA"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "gradient_accumulator"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "gradient_squared_accumulator"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "global_step"
+    description: <<END
+Training step number. Must be a scalar.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, updating of the var and accum tensors will be protected by
+a lock; otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Update \'*var\' according to the proximal adagrad scheme."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceApplyAdam.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceApplyAdam.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bea1fd67627cc69354f81da7cf36d20babb9f38d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceApplyAdam.pbtxt
@@ -0,0 +1,84 @@
+op {
+  graph_op_name: "ResourceApplyAdam"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "m"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "v"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "beta1_power"
+    description: <<END
+Must be a scalar.
+END
+  }
+  in_arg {
+    name: "beta2_power"
+    description: <<END
+Must be a scalar.
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "beta1"
+    description: <<END
+Momentum factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "beta2"
+    description: <<END
+Momentum factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "epsilon"
+    description: <<END
+Ridge term. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var, m, and v tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  attr {
+    name: "use_nesterov"
+    description: <<END
+If `True`, uses the nesterov update.
+END
+  }
+  summary: "Update \'*var\' according to the Adam algorithm."
+  description: <<END
+lr_t <- learning_rate * sqrt(1 - beta2^t) / (1 - beta1^t)
+m_t <- beta1 * m_{t-1} + (1 - beta1) * g_t
+v_t <- beta2 * v_{t-1} + (1 - beta2) * g_t * g_t
+variable <- variable - lr_t * m_t / (sqrt(v_t) + epsilon)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceApplyCenteredRMSProp.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceApplyCenteredRMSProp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9cc033cc897bbc2296b0bf77c5f4e18171a4646b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceApplyCenteredRMSProp.pbtxt
@@ -0,0 +1,80 @@
+op {
+  graph_op_name: "ResourceApplyCenteredRMSProp"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "mg"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "ms"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "mom"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "rho"
+    description: <<END
+Decay rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "epsilon"
+    description: <<END
+Ridge term. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var, mg, ms, and mom tensors is
+protected by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update \'*var\' according to the centered RMSProp algorithm."
+  description: <<END
+The centered RMSProp algorithm uses an estimate of the centered second moment
+(i.e., the variance) for normalization, as opposed to regular RMSProp, which
+uses the (uncentered) second moment. This often helps with training, but is
+slightly more expensive in terms of computation and memory.
+
+Note that in dense implementation of this algorithm, mg, ms, and mom will
+update even if the grad is zero, but in this sparse implementation, mg, ms,
+and mom will not update in iterations during which the grad is zero.
+
+mean_square = decay * mean_square + (1-decay) * gradient ** 2
+mean_grad = decay * mean_grad + (1-decay) * gradient
+
+Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2)
+
+mg <- rho * mg_{t-1} + (1-rho) * grad
+ms <- rho * ms_{t-1} + (1-rho) * grad * grad
+mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms - mg * mg + epsilon)
+var <- var - mom
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceApplyFtrl.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceApplyFtrl.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a6a29b164e2c7cc5cc6230fe6cc4248563de9978
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceApplyFtrl.pbtxt
@@ -0,0 +1,67 @@
+op {
+  graph_op_name: "ResourceApplyFtrl"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "linear"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regulariation. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 regulariation. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "lr_power"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var and accum tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update \'*var\' according to the Ftrl-proximal scheme."
+  description: <<END
+accum_new = accum + grad * grad
+linear += grad - (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
+quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
+var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
+accum = accum_new
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceApplyFtrlV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceApplyFtrlV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a71c835b7896374801fba29983481c8faa26baa6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceApplyFtrlV2.pbtxt
@@ -0,0 +1,69 @@
+op {
+  graph_op_name: "ResourceApplyFtrlV2"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "linear"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regulariation. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 shrinkage regulariation. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "lr_power"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var and accum tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update \'*var\' according to the Ftrl-proximal scheme."
+  description: <<END
+grad_with_shrinkage = grad + 2 * l2_shrinkage * var
+accum_new = accum + grad_with_shrinkage * grad_with_shrinkage
+linear += grad_with_shrinkage +
+    (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
+quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
+var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
+accum = accum_new
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceApplyGradientDescent.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceApplyGradientDescent.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..01f235f224818104522bce46e4530c639d1ab49a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceApplyGradientDescent.pbtxt
@@ -0,0 +1,29 @@
+op {
+  graph_op_name: "ResourceApplyGradientDescent"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "alpha"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "delta"
+    description: <<END
+The change.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, the subtraction will be protected by a lock;
+otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Update \'*var\' by subtracting \'alpha\' * \'delta\' from it."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceApplyMomentum.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceApplyMomentum.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d1a84a4c34bb7df8e5a6d8d16d29322f26b13657
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceApplyMomentum.pbtxt
@@ -0,0 +1,56 @@
+op {
+  graph_op_name: "ResourceApplyMomentum"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "momentum"
+    description: <<END
+Momentum. Must be a scalar.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var and accum tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  attr {
+    name: "use_nesterov"
+    description: <<END
+If `True`, the tensor passed to compute grad will be
+var - lr * momentum * accum, so in the end, the var you get is actually
+var - lr * momentum * accum.
+END
+  }
+  summary: "Update \'*var\' according to the momentum scheme. Set use_nesterov = True if you"
+  description: <<END
+want to use Nesterov momentum.
+
+accum = accum * momentum + grad
+var -= lr * accum
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceApplyProximalAdagrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceApplyProximalAdagrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1eaa86ea14af40a8b0219b62822bb2249d871401
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceApplyProximalAdagrad.pbtxt
@@ -0,0 +1,52 @@
+op {
+  graph_op_name: "ResourceApplyProximalAdagrad"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, updating of the var and accum tensors will be protected by
+a lock; otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Update \'*var\' and \'*accum\' according to FOBOS with Adagrad learning rate."
+  description: <<END
+accum += grad * grad
+prox_v = var - lr * grad * (1 / sqrt(accum))
+var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceApplyProximalGradientDescent.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceApplyProximalGradientDescent.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c22e931a2b68ebc03d131d4a6ac84e26c8f2d463
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceApplyProximalGradientDescent.pbtxt
@@ -0,0 +1,45 @@
+op {
+  graph_op_name: "ResourceApplyProximalGradientDescent"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "alpha"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "delta"
+    description: <<END
+The change.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, the subtraction will be protected by a lock;
+otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Update \'*var\' as FOBOS algorithm with fixed learning rate."
+  description: <<END
+prox_v = var - alpha * delta
+var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceApplyRMSProp.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceApplyRMSProp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2a24f23f9cfd1d709de606539dc175676aa5fa19
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceApplyRMSProp.pbtxt
@@ -0,0 +1,66 @@
+op {
+  graph_op_name: "ResourceApplyRMSProp"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "ms"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "mom"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "rho"
+    description: <<END
+Decay rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "epsilon"
+    description: <<END
+Ridge term. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var, ms, and mom tensors is protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update \'*var\' according to the RMSProp algorithm."
+  description: <<END
+Note that in dense implementation of this algorithm, ms and mom will
+update even if the grad is zero, but in this sparse implementation, ms
+and mom will not update in iterations during which the grad is zero.
+
+mean_square = decay * mean_square + (1-decay) * gradient ** 2
+Delta = learning_rate * gradient / sqrt(mean_square + epsilon)
+
+ms <- rho * ms_{t-1} + (1-rho) * grad * grad
+mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
+var <- var - mom
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceCountUpTo.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceCountUpTo.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bc70d79a1e34f30a8e8583b5d78ce1ec62da3f04
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceCountUpTo.pbtxt
@@ -0,0 +1,24 @@
+op {
+  graph_op_name: "ResourceCountUpTo"
+  in_arg {
+    name: "resource"
+    description: <<END
+Should be from a scalar `Variable` node.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A copy of the input before increment. If nothing else modifies the
+input, the values produced will all be distinct.
+END
+  }
+  attr {
+    name: "limit"
+    description: <<END
+If incrementing ref would bring it above limit, instead generates an
+'OutOfRange' error.
+END
+  }
+  summary: "Increments variable pointed to by \'resource\' until it reaches \'limit\'."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceGather.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceGather.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ae5d38a5014753afc592653bc088af8a19514fc3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceGather.pbtxt
@@ -0,0 +1,19 @@
+op {
+  graph_op_name: "ResourceGather"
+  summary: "Gather slices from the variable pointed to by `resource` according to `indices`."
+  description: <<END
+`indices` must be an integer tensor of any dimension (usually 0-D or 1-D).
+Produces an output tensor with shape `indices.shape + params.shape[1:]` where:
+
+```python
+    # Scalar indices
+    output[:, ..., :] = params[indices, :, ... :]
+
+    # Vector indices
+    output[i, :, ..., :] = params[indices[i], :, ... :]
+
+    # Higher rank indices
+    output[i, ..., j, :, ... :] = params[indices[i, ..., j], :, ..., :]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceScatterAdd.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceScatterAdd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9e0de08267288e32e34cef323761cf4566fce128
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceScatterAdd.pbtxt
@@ -0,0 +1,43 @@
+op {
+  graph_op_name: "ResourceScatterAdd"
+  in_arg {
+    name: "resource"
+    description: <<END
+Should be from a `Variable` node.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A tensor of indices into the first dimension of `ref`.
+END
+  }
+  in_arg {
+    name: "updates"
+    description: <<END
+A tensor of updated values to add to `ref`.
+END
+  }
+  summary: "Adds sparse updates to the variable referenced by `resource`."
+  description: <<END
+This operation computes
+
+    # Scalar indices
+    ref[indices, ...] += updates[...]
+
+    # Vector indices (for each i)
+    ref[indices[i], ...] += updates[i, ...]
+
+    # High rank indices (for each i, ..., j)
+    ref[indices[i, ..., j], ...] += updates[i, ..., j, ...]
+
+Duplicate entries are handled correctly: if multiple `indices` reference
+the same location, their contributions add.
+
+Requires `updates.shape = indices.shape + ref.shape[1:]`.
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
+</div>
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceScatterUpdate.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceScatterUpdate.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..947535c6c8f5087392d254460fef2fc8941dba72
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceScatterUpdate.pbtxt
@@ -0,0 +1,34 @@
+op {
+  graph_op_name: "ResourceScatterUpdate"
+  in_arg {
+    name: "resource"
+    description: <<END
+Should be from a `Variable` node.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A tensor of indices into the first dimension of `ref`.
+END
+  }
+  in_arg {
+    name: "updates"
+    description: <<END
+A tensor of updated values to add to `ref`.
+END
+  }
+  summary: "Assigns sparse updates to the variable referenced by `resource`."
+  description: <<END
+This operation computes
+
+    # Scalar indices
+    ref[indices, ...] = updates[...]
+
+    # Vector indices (for each i)
+    ref[indices[i], ...] = updates[i, ...]
+
+    # High rank indices (for each i, ..., j)
+    ref[indices[i, ..., j], ...] = updates[i, ..., j, ...]
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyAdadelta.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyAdadelta.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1bea6d614c58315dd1ceb6178c48fce36289e8bd
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyAdadelta.pbtxt
@@ -0,0 +1,53 @@
+op {
+  graph_op_name: "ResourceSparseApplyAdadelta"
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum_update"
+    description: <<END
+: Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Learning rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "rho"
+    description: <<END
+Decay factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "epsilon"
+    description: <<END
+Constant factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var and accum.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, updating of the var and accum tensors will be protected by
+a lock; otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "var: Should be from a Variable()."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyAdagrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyAdagrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f6463947601a3cfd39008b27077e319071f7e912
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyAdagrad.pbtxt
@@ -0,0 +1,47 @@
+op {
+  graph_op_name: "ResourceSparseApplyAdagrad"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Learning rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var and accum.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var and accum tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update relevant entries in \'*var\' and \'*accum\' according to the adagrad scheme."
+  description: <<END
+That is for rows we have grad for, we update var and accum as follows:
+accum += grad * grad
+var -= lr * grad * (1 / sqrt(accum))
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyAdagradDA.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyAdagradDA.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..96833d8f097bb92cf59cca222d7198b7d8df65cf
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyAdagradDA.pbtxt
@@ -0,0 +1,65 @@
+op {
+  graph_op_name: "ResourceSparseApplyAdagradDA"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "gradient_accumulator"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "gradient_squared_accumulator"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var and accum.
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Learning rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "global_step"
+    description: <<END
+Training step number. Must be a scalar.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, updating of the var and accum tensors will be protected by
+a lock; otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Update entries in \'*var\' and \'*accum\' according to the proximal adagrad scheme."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyCenteredRMSProp.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyCenteredRMSProp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..433d040fe741b9c8b2b6dbe7b71cb44bb4c6c0d9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyCenteredRMSProp.pbtxt
@@ -0,0 +1,84 @@
+op {
+  graph_op_name: "ResourceSparseApplyCenteredRMSProp"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "mg"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "ms"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "mom"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "rho"
+    description: <<END
+Decay rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "epsilon"
+    description: <<END
+Ridge term. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var, ms and mom.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var, mg, ms, and mom tensors is
+protected by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update \'*var\' according to the centered RMSProp algorithm."
+  description: <<END
+The centered RMSProp algorithm uses an estimate of the centered second moment
+(i.e., the variance) for normalization, as opposed to regular RMSProp, which
+uses the (uncentered) second moment. This often helps with training, but is
+slightly more expensive in terms of computation and memory.
+
+Note that in dense implementation of this algorithm, mg, ms, and mom will
+update even if the grad is zero, but in this sparse implementation, mg, ms,
+and mom will not update in iterations during which the grad is zero.
+
+mean_square = decay * mean_square + (1-decay) * gradient ** 2
+mean_grad = decay * mean_grad + (1-decay) * gradient
+Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2)
+
+ms <- rho * ms_{t-1} + (1-rho) * grad * grad
+mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
+var <- var - mom
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyFtrl.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyFtrl.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f75272a63b135ef5324a86fab4b89f2a9ae48a09
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyFtrl.pbtxt
@@ -0,0 +1,74 @@
+op {
+  graph_op_name: "ResourceSparseApplyFtrl"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "linear"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var and accum.
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "lr_power"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var and accum tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update relevant entries in \'*var\' according to the Ftrl-proximal scheme."
+  description: <<END
+That is for rows we have grad for, we update var, accum and linear as follows:
+accum_new = accum + grad * grad
+linear += grad + (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
+quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
+var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
+accum = accum_new
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyFtrlV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyFtrlV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..45ea013ce89782972144a2560b81acbefebe53f5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyFtrlV2.pbtxt
@@ -0,0 +1,76 @@
+op {
+  graph_op_name: "ResourceSparseApplyFtrlV2"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "linear"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var and accum.
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 shrinkage regulariation. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "lr_power"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var and accum tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update relevant entries in \'*var\' according to the Ftrl-proximal scheme."
+  description: <<END
+That is for rows we have grad for, we update var, accum and linear as follows:
+grad_with_shrinkage = grad + 2 * l2_shrinkage * var
+accum_new = accum + grad_with_shrinkage * grad_with_shrinkage
+linear += grad_with_shrinkage +
+    (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
+quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
+var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
+accum = accum_new
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyMomentum.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyMomentum.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..671465377a175d79e1608e4a68bef75bc129e853
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyMomentum.pbtxt
@@ -0,0 +1,64 @@
+op {
+  graph_op_name: "ResourceSparseApplyMomentum"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Learning rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var and accum.
+END
+  }
+  in_arg {
+    name: "momentum"
+    description: <<END
+Momentum. Must be a scalar.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var and accum tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  attr {
+    name: "use_nesterov"
+    description: <<END
+If `True`, the tensor passed to compute grad will be
+var - lr * momentum * accum, so in the end, the var you get is actually
+var - lr * momentum * accum.
+END
+  }
+  summary: "Update relevant entries in \'*var\' and \'*accum\' according to the momentum scheme."
+  description: <<END
+Set use_nesterov = True if you want to use Nesterov momentum.
+
+That is for rows we have grad for, we update var and accum as follows:
+
+accum = accum * momentum + grad
+var -= lr * accum
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyProximalAdagrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyProximalAdagrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f3a588adaaaa3043a48987e2f06dadc8f78230e3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyProximalAdagrad.pbtxt
@@ -0,0 +1,60 @@
+op {
+  graph_op_name: "ResourceSparseApplyProximalAdagrad"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Learning rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var and accum.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, updating of the var and accum tensors will be protected by
+a lock; otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Sparse update entries in \'*var\' and \'*accum\' according to FOBOS algorithm."
+  description: <<END
+That is for rows we have grad for, we update var and accum as follows:
+accum += grad * grad
+prox_v = var
+prox_v -= lr * grad * (1 / sqrt(accum))
+var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyProximalGradientDescent.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyProximalGradientDescent.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4a6333c0b56212d9ae36e82562283919f1d02e03
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyProximalGradientDescent.pbtxt
@@ -0,0 +1,52 @@
+op {
+  graph_op_name: "ResourceSparseApplyProximalGradientDescent"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "alpha"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var and accum.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, the subtraction will be protected by a lock;
+otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Sparse update \'*var\' as FOBOS algorithm with fixed learning rate."
+  description: <<END
+That is for rows we have grad for, we update var as follows:
+prox_v = var - alpha * grad
+var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyRMSProp.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyRMSProp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a6310711ea6fac8ffaf799a192ff859cf9457966
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyRMSProp.pbtxt
@@ -0,0 +1,72 @@
+op {
+  graph_op_name: "ResourceSparseApplyRMSProp"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "ms"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "mom"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "rho"
+    description: <<END
+Decay rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "epsilon"
+    description: <<END
+Ridge term. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var, ms and mom.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var, ms, and mom tensors is protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update \'*var\' according to the RMSProp algorithm."
+  description: <<END
+Note that in dense implementation of this algorithm, ms and mom will
+update even if the grad is zero, but in this sparse implementation, ms
+and mom will not update in iterations during which the grad is zero.
+
+mean_square = decay * mean_square + (1-decay) * gradient ** 2
+Delta = learning_rate * gradient / sqrt(mean_square + epsilon)
+
+ms <- rho * ms_{t-1} + (1-rho) * grad * grad
+mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
+var <- var - mom
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceStridedSliceAssign.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceStridedSliceAssign.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ec8acbb5bf4b7fc8242ce21606e73a234b0819a2
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceStridedSliceAssign.pbtxt
@@ -0,0 +1,12 @@
+op {
+  graph_op_name: "ResourceStridedSliceAssign"
+  summary: "Assign `value` to the sliced l-value reference of `ref`."
+  description: <<END
+The values of `value` are assigned to the positions in the variable
+`ref` that are selected by the slice parameters. The slice parameters
+`begin, `end`, `strides`, etc. work exactly as in `StridedSlice`.
+
+NOTE this op currently does not support broadcasting and so `value`'s
+shape must be exactly the shape produced by the slice of `ref`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Restore.pbtxt b/tensorflow/core/api_def/base_api/api_def_Restore.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..816b79cf5357c74d1e92c3bb5ebcd28b69b02e7e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Restore.pbtxt
@@ -0,0 +1,55 @@
+op {
+  graph_op_name: "Restore"
+  in_arg {
+    name: "file_pattern"
+    description: <<END
+Must have a single element. The pattern of the files from
+which we read the tensor.
+END
+  }
+  in_arg {
+    name: "tensor_name"
+    description: <<END
+Must have a single element. The name of the tensor to be
+restored.
+END
+  }
+  out_arg {
+    name: "tensor"
+    description: <<END
+The restored tensor.
+END
+  }
+  attr {
+    name: "dt"
+    description: <<END
+The type of the tensor to be restored.
+END
+  }
+  attr {
+    name: "preferred_shard"
+    description: <<END
+Index of file to open first if multiple files match
+`file_pattern`.
+END
+  }
+  summary: "Restores a tensor from checkpoint files."
+  description: <<END
+Reads a tensor stored in one or several files. If there are several files (for
+instance because a tensor was saved as slices), `file_pattern` may contain
+wildcard symbols (`*` and `?`) in the filename portion only, not in the
+directory portion.
+
+If a `file_pattern` matches several files, `preferred_shard` can be used to hint
+in which file the requested tensor is likely to be found. This op will first
+open the file at index `preferred_shard` in the list of matching files and try
+to restore tensors from that file.  Only if some tensors or tensor slices are
+not found in that first file, then the Op opens all the files. Setting
+`preferred_shard` to match the value passed as the `shard` input
+of a matching `Save` Op may speed up Restore.  This attribute only affects
+performance, not correctness.  The default value -1 means files are processed in
+order.
+
+See also `RestoreSlice`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RestoreSlice.pbtxt b/tensorflow/core/api_def/base_api/api_def_RestoreSlice.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e57b1ea42d3c790a87c3206113ca57c03e189343
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RestoreSlice.pbtxt
@@ -0,0 +1,52 @@
+op {
+  graph_op_name: "RestoreSlice"
+  in_arg {
+    name: "file_pattern"
+    description: <<END
+Must have a single element. The pattern of the files from
+which we read the tensor.
+END
+  }
+  in_arg {
+    name: "tensor_name"
+    description: <<END
+Must have a single element. The name of the tensor to be
+restored.
+END
+  }
+  in_arg {
+    name: "shape_and_slice"
+    description: <<END
+Scalar. The shapes and slice specifications to use when
+restoring a tensors.
+END
+  }
+  out_arg {
+    name: "tensor"
+    description: <<END
+The restored tensor.
+END
+  }
+  attr {
+    name: "dt"
+    description: <<END
+The type of the tensor to be restored.
+END
+  }
+  attr {
+    name: "preferred_shard"
+    description: <<END
+Index of file to open first if multiple files match
+`file_pattern`. See the documentation for `Restore`.
+END
+  }
+  summary: "Restores a tensor from checkpoint files."
+  description: <<END
+This is like `Restore` except that restored tensor can be listed as filling
+only a slice of a larger tensor.  `shape_and_slice` specifies the shape of the
+larger tensor and the slice that the restored tensor covers.
+
+The `shape_and_slice` input has the same format as the
+elements of the `shapes_and_slices` input of the `SaveSlices` op.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RestoreV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_RestoreV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5a64ef36d05727e6f4c67e1f7fb4cf68545823df
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RestoreV2.pbtxt
@@ -0,0 +1,52 @@
+op {
+  graph_op_name: "RestoreV2"
+  in_arg {
+    name: "prefix"
+    description: <<END
+Must have a single element.  The prefix of a V2 checkpoint.
+END
+  }
+  in_arg {
+    name: "tensor_names"
+    description: <<END
+shape {N}.  The names of the tensors to be restored.
+END
+  }
+  in_arg {
+    name: "shape_and_slices"
+    description: <<END
+shape {N}.  The slice specs of the tensors to be restored.
+Empty strings indicate that they are non-partitioned tensors.
+END
+  }
+  out_arg {
+    name: "tensors"
+    description: <<END
+shape {N}.  The restored tensors, whose shapes are read from the
+checkpoint directly.
+END
+  }
+  attr {
+    name: "dtypes"
+    description: <<END
+shape {N}.  The list of expected dtype for the tensors.  Must match
+those stored in the checkpoint.
+END
+  }
+  summary: "Restores tensors from a V2 checkpoint."
+  description: <<END
+For backward compatibility with the V1 format, this Op currently allows
+restoring from a V1 checkpoint as well:
+  - This Op first attempts to find the V2 index file pointed to by "prefix", and
+    if found proceed to read it as a V2 checkpoint;
+  - Otherwise the V1 read path is invoked.
+Relying on this behavior is not recommended, as the ability to fall back to read
+V1 might be deprecated and eventually removed.
+
+By default, restores the named tensors in full.  If the caller wishes to restore
+specific slices of stored tensors, "shape_and_slices" should be non-empty
+strings and correspondingly well-formed.
+
+Callers must ensure all the named tensors are indeed stored in the checkpoint.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Reverse.pbtxt b/tensorflow/core/api_def/base_api/api_def_Reverse.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..83d7ee77989ab51488c651b6b2d0958bbacb276e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Reverse.pbtxt
@@ -0,0 +1,69 @@
+op {
+  graph_op_name: "Reverse"
+  visibility: SKIP
+  in_arg {
+    name: "tensor"
+    description: <<END
+Up to 8-D.
+END
+  }
+  in_arg {
+    name: "dims"
+    description: <<END
+1-D. The dimensions to reverse.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The same shape as `tensor`.
+END
+  }
+  summary: "Reverses specific dimensions of a tensor."
+  description: <<END
+Given a `tensor`, and a `bool` tensor `dims` representing the dimensions
+of `tensor`, this operation reverses each dimension i of `tensor` where
+`dims[i]` is `True`.
+
+`tensor` can have up to 8 dimensions. The number of dimensions
+of `tensor` must equal the number of elements in `dims`. In other words:
+
+`rank(tensor) = size(dims)`
+
+For example:
+
+```
+# tensor 't' is [[[[ 0,  1,  2,  3],
+#                  [ 4,  5,  6,  7],
+#                  [ 8,  9, 10, 11]],
+#                 [[12, 13, 14, 15],
+#                  [16, 17, 18, 19],
+#                  [20, 21, 22, 23]]]]
+# tensor 't' shape is [1, 2, 3, 4]
+
+# 'dims' is [False, False, False, True]
+reverse(t, dims) ==> [[[[ 3,  2,  1,  0],
+                        [ 7,  6,  5,  4],
+                        [ 11, 10, 9, 8]],
+                       [[15, 14, 13, 12],
+                        [19, 18, 17, 16],
+                        [23, 22, 21, 20]]]]
+
+# 'dims' is [False, True, False, False]
+reverse(t, dims) ==> [[[[12, 13, 14, 15],
+                        [16, 17, 18, 19],
+                        [20, 21, 22, 23]
+                       [[ 0,  1,  2,  3],
+                        [ 4,  5,  6,  7],
+                        [ 8,  9, 10, 11]]]]
+
+# 'dims' is [False, False, True, False]
+reverse(t, dims) ==> [[[[8, 9, 10, 11],
+                        [4, 5, 6, 7],
+                        [0, 1, 2, 3]]
+                       [[20, 21, 22, 23],
+                        [16, 17, 18, 19],
+                        [12, 13, 14, 15]]]]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReverseSequence.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReverseSequence.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9ee4ead539f3922ce715f62b364757df1943baae
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReverseSequence.pbtxt
@@ -0,0 +1,91 @@
+op {
+  graph_op_name: "ReverseSequence"
+  in_arg {
+    name: "input"
+    description: <<END
+The input to reverse.
+END
+  }
+  in_arg {
+    name: "seq_lengths"
+    description: <<END
+1-D with length `input.dims(batch_dim)` and
+`max(seq_lengths) <= input.dims(seq_dim)`
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The partially reversed input. It has the same shape as `input`.
+END
+  }
+  attr {
+    name: "seq_dim"
+    description: <<END
+The dimension which is partially reversed.
+END
+  }
+  attr {
+    name: "batch_dim"
+    description: <<END
+The dimension along which reversal is performed.
+END
+  }
+  summary: "Reverses variable length slices."
+  description: <<END
+This op first slices `input` along the dimension `batch_dim`, and for each
+slice `i`, reverses the first `seq_lengths[i]` elements along
+the dimension `seq_dim`.
+
+The elements of `seq_lengths` must obey `seq_lengths[i] <= input.dims[seq_dim]`,
+and `seq_lengths` must be a vector of length `input.dims[batch_dim]`.
+
+The output slice `i` along dimension `batch_dim` is then given by input
+slice `i`, with the first `seq_lengths[i]` slices along dimension
+`seq_dim` reversed.
+
+For example:
+
+```
+# Given this:
+batch_dim = 0
+seq_dim = 1
+input.dims = (4, 8, ...)
+seq_lengths = [7, 2, 3, 5]
+
+# then slices of input are reversed on seq_dim, but only up to seq_lengths:
+output[0, 0:7, :, ...] = input[0, 7:0:-1, :, ...]
+output[1, 0:2, :, ...] = input[1, 2:0:-1, :, ...]
+output[2, 0:3, :, ...] = input[2, 3:0:-1, :, ...]
+output[3, 0:5, :, ...] = input[3, 5:0:-1, :, ...]
+
+# while entries past seq_lens are copied through:
+output[0, 7:, :, ...] = input[0, 7:, :, ...]
+output[1, 2:, :, ...] = input[1, 2:, :, ...]
+output[2, 3:, :, ...] = input[2, 3:, :, ...]
+output[3, 2:, :, ...] = input[3, 2:, :, ...]
+```
+
+In contrast, if:
+
+```
+# Given this:
+batch_dim = 2
+seq_dim = 0
+input.dims = (8, ?, 4, ...)
+seq_lengths = [7, 2, 3, 5]
+
+# then slices of input are reversed on seq_dim, but only up to seq_lengths:
+output[0:7, :, 0, :, ...] = input[7:0:-1, :, 0, :, ...]
+output[0:2, :, 1, :, ...] = input[2:0:-1, :, 1, :, ...]
+output[0:3, :, 2, :, ...] = input[3:0:-1, :, 2, :, ...]
+output[0:5, :, 3, :, ...] = input[5:0:-1, :, 3, :, ...]
+
+# while entries past seq_lens are copied through:
+output[7:, :, 0, :, ...] = input[7:, :, 0, :, ...]
+output[2:, :, 1, :, ...] = input[2:, :, 1, :, ...]
+output[3:, :, 2, :, ...] = input[3:, :, 2, :, ...]
+output[2:, :, 3, :, ...] = input[2:, :, 3, :, ...]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ReverseV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_ReverseV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0c9e4c29be89b13541e161d2a1a38c3d33b79edf
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ReverseV2.pbtxt
@@ -0,0 +1,74 @@
+op {
+  graph_op_name: "ReverseV2"
+  endpoint {
+    name: "Reverse"
+  }
+  in_arg {
+    name: "tensor"
+    description: <<END
+Up to 8-D.
+END
+  }
+  in_arg {
+    name: "axis"
+    description: <<END
+1-D. The indices of the dimensions to reverse. Must be in the range
+`[-rank(tensor), rank(tensor))`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The same shape as `tensor`.
+END
+  }
+  summary: "Reverses specific dimensions of a tensor."
+  description: <<END
+NOTE `tf.reverse` has now changed behavior in preparation for 1.0.
+`tf.reverse_v2` is currently an alias that will be deprecated before TF 1.0.
+
+Given a `tensor`, and a `int32` tensor `axis` representing the set of
+dimensions of `tensor` to reverse. This operation reverses each dimension
+`i` for which there exists `j` s.t. `axis[j] == i`.
+
+`tensor` can have up to 8 dimensions. The number of dimensions specified
+in `axis` may be 0 or more entries. If an index is specified more than
+once, a InvalidArgument error is raised.
+
+For example:
+
+```
+# tensor 't' is [[[[ 0,  1,  2,  3],
+#                  [ 4,  5,  6,  7],
+#                  [ 8,  9, 10, 11]],
+#                 [[12, 13, 14, 15],
+#                  [16, 17, 18, 19],
+#                  [20, 21, 22, 23]]]]
+# tensor 't' shape is [1, 2, 3, 4]
+
+# 'dims' is [3] or 'dims' is [-1]
+reverse(t, dims) ==> [[[[ 3,  2,  1,  0],
+                        [ 7,  6,  5,  4],
+                        [ 11, 10, 9, 8]],
+                       [[15, 14, 13, 12],
+                        [19, 18, 17, 16],
+                        [23, 22, 21, 20]]]]
+
+# 'dims' is '[1]' (or 'dims' is '[-3]')
+reverse(t, dims) ==> [[[[12, 13, 14, 15],
+                        [16, 17, 18, 19],
+                        [20, 21, 22, 23]
+                       [[ 0,  1,  2,  3],
+                        [ 4,  5,  6,  7],
+                        [ 8,  9, 10, 11]]]]
+
+# 'dims' is '[2]' (or 'dims' is '[-2]')
+reverse(t, dims) ==> [[[[8, 9, 10, 11],
+                        [4, 5, 6, 7],
+                        [0, 1, 2, 3]]
+                       [[20, 21, 22, 23],
+                        [16, 17, 18, 19],
+                        [12, 13, 14, 15]]]]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RightShift.pbtxt b/tensorflow/core/api_def/base_api/api_def_RightShift.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a7c56a00f1f81b5b9de94a759bc4e32f0d1e05c7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RightShift.pbtxt
@@ -0,0 +1,11 @@
+op {
+  graph_op_name: "RightShift"
+  summary: "Elementwise computes the bitwise right-shift of `x` and `y`."
+  description: <<END
+Performs a logical shift for unsigned integer types, and an arithmetic shift
+for signed integer types.
+
+If `y` is negative, or greater than or equal to than the width of `x` in bits
+the result is implementation defined.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Rint.pbtxt b/tensorflow/core/api_def/base_api/api_def_Rint.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..73699c9b6cf58ea02e64fe6cc45c42d8e8e76d73
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Rint.pbtxt
@@ -0,0 +1,15 @@
+op {
+  graph_op_name: "Rint"
+  summary: "Returns element-wise integer closest to x."
+  description: <<END
+If the result is midway between two representable values,
+the even representable is chosen.
+For example:
+
+```
+rint(-1.5) ==> -2.0
+rint(0.5000001) ==> 1.0
+rint([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) ==> [-2., -2., -0., 0., 2., 2., 2.]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Round.pbtxt b/tensorflow/core/api_def/base_api/api_def_Round.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2a7105eae74fd2e6297c1c3d0b6b097751bfdc1c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Round.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "Round"
+  summary: "Rounds the values of a tensor to the nearest integer, element-wise."
+  description: <<END
+Rounds half to even.  Also known as bankers rounding. If you want to round
+according to the current system rounding mode use std::cint.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Rsqrt.pbtxt b/tensorflow/core/api_def/base_api/api_def_Rsqrt.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a7f768c505b925e2cc07db5de82c0973e719c4ec
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Rsqrt.pbtxt
@@ -0,0 +1,7 @@
+op {
+  graph_op_name: "Rsqrt"
+  summary: "Computes reciprocal of square root of x element-wise."
+  description: <<END
+I.e., \\(y = 1 / \sqrt{x}\\).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_RsqrtGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_RsqrtGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..501936c5c8881147f7bfc705857af71806a4d1c9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_RsqrtGrad.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "RsqrtGrad"
+  visibility: HIDDEN
+  summary: "Computes the gradient for the rsqrt of `x` wrt its input."
+  description: <<END
+Specifically, `grad = dy * -0.5 * y^3`, where `y = rsqrt(x)`, and `dy`
+is the corresponding input gradient.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_S.pbtxt b/tensorflow/core/api_def/base_api/api_def_S.pbtxt
deleted file mode 100644
index 9c53f9ac6207ed4a3214bc38a8a417364e74e776..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_S.pbtxt
+++ /dev/null
@@ -1,2678 +0,0 @@
-op {
-  graph_op_name: "SampleDistortedBoundingBox"
-  endpoint {
-    name: "SampleDistortedBoundingBox"
-  }
-  summary: "Generate a single randomly distorted bounding box for an image."
-  description: <<END
-Bounding box annotations are often supplied in addition to ground-truth labels
-in image recognition or object localization tasks. A common technique for
-training such a system is to randomly distort an image while preserving
-its content, i.e. *data augmentation*. This Op outputs a randomly distorted
-localization of an object, i.e. bounding box, given an `image_size`,
-`bounding_boxes` and a series of constraints.
-
-The output of this Op is a single bounding box that may be used to crop the
-original image. The output is returned as 3 tensors: `begin`, `size` and
-`bboxes`. The first 2 tensors can be fed directly into `tf.slice` to crop the
-image. The latter may be supplied to `tf.image.draw_bounding_boxes` to visualize
-what the bounding box looks like.
-
-Bounding boxes are supplied and returned as `[y_min, x_min, y_max, x_max]`. The
-bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
-height of the underlying image.
-
-For example,
-
-```python
-    # Generate a single distorted bounding box.
-    begin, size, bbox_for_draw = tf.image.sample_distorted_bounding_box(
-        tf.shape(image),
-        bounding_boxes=bounding_boxes)
-
-    # Draw the bounding box in an image summary.
-    image_with_box = tf.image.draw_bounding_boxes(tf.expand_dims(image, 0),
-                                                  bbox_for_draw)
-    tf.image_summary('images_with_box', image_with_box)
-
-    # Employ the bounding box to distort the image.
-    distorted_image = tf.slice(image, begin, size)
-```
-
-Note that if no bounding box information is available, setting
-`use_image_if_no_bounding_boxes = true` will assume there is a single implicit
-bounding box covering the whole image. If `use_image_if_no_bounding_boxes` is
-false and no bounding boxes are supplied, an error is raised.
-END
-}
-op {
-  graph_op_name: "SampleDistortedBoundingBoxV2"
-  endpoint {
-    name: "SampleDistortedBoundingBoxV2"
-  }
-  summary: "Generate a single randomly distorted bounding box for an image."
-  description: <<END
-Bounding box annotations are often supplied in addition to ground-truth labels
-in image recognition or object localization tasks. A common technique for
-training such a system is to randomly distort an image while preserving
-its content, i.e. *data augmentation*. This Op outputs a randomly distorted
-localization of an object, i.e. bounding box, given an `image_size`,
-`bounding_boxes` and a series of constraints.
-
-The output of this Op is a single bounding box that may be used to crop the
-original image. The output is returned as 3 tensors: `begin`, `size` and
-`bboxes`. The first 2 tensors can be fed directly into `tf.slice` to crop the
-image. The latter may be supplied to `tf.image.draw_bounding_boxes` to visualize
-what the bounding box looks like.
-
-Bounding boxes are supplied and returned as `[y_min, x_min, y_max, x_max]`. The
-bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
-height of the underlying image.
-
-For example,
-
-```python
-    # Generate a single distorted bounding box.
-    begin, size, bbox_for_draw = tf.image.sample_distorted_bounding_box(
-        tf.shape(image),
-        bounding_boxes=bounding_boxes)
-
-    # Draw the bounding box in an image summary.
-    image_with_box = tf.image.draw_bounding_boxes(tf.expand_dims(image, 0),
-                                                  bbox_for_draw)
-    tf.image_summary('images_with_box', image_with_box)
-
-    # Employ the bounding box to distort the image.
-    distorted_image = tf.slice(image, begin, size)
-```
-
-Note that if no bounding box information is available, setting
-`use_image_if_no_bounding_boxes = true` will assume there is a single implicit
-bounding box covering the whole image. If `use_image_if_no_bounding_boxes` is
-false and no bounding boxes are supplied, an error is raised.
-END
-}
-op {
-  graph_op_name: "Save"
-  endpoint {
-    name: "Save"
-  }
-  summary: "Saves the input tensors to disk."
-  description: <<END
-The size of `tensor_names` must match the number of tensors in `data`. `data[i]`
-is written to `filename` with name `tensor_names[i]`.
-
-See also `SaveSlices`.
-END
-}
-op {
-  graph_op_name: "SaveIterator"
-  endpoint {
-    name: "SaveIterator"
-  }
-  summary: "Saves the state of the `iterator` at `path`."
-  description: <<END
-This state can be restored using "RestoreIterator".
-END
-}
-op {
-  graph_op_name: "SaveSlices"
-  endpoint {
-    name: "SaveSlices"
-  }
-  summary: "Saves input tensors slices to disk."
-  description: <<END
-This is like `Save` except that tensors can be listed in the saved file as being
-a slice of a larger tensor.  `shapes_and_slices` specifies the shape of the
-larger tensor and the slice that this tensor covers. `shapes_and_slices` must
-have as many elements as `tensor_names`.
-
-Elements of the `shapes_and_slices` input must either be:
-
-*  The empty string, in which case the corresponding tensor is
-   saved normally.
-*  A string of the form `dim0 dim1 ... dimN-1 slice-spec` where the
-   `dimI` are the dimensions of the larger tensor and `slice-spec`
-   specifies what part is covered by the tensor to save.
-
-`slice-spec` itself is a `:`-separated list: `slice0:slice1:...:sliceN-1`
-where each `sliceI` is either:
-
-*  The string `-` meaning that the slice covers all indices of this dimension
-*  `start,length` where `start` and `length` are integers.  In that
-   case the slice covers `length` indices starting at `start`.
-
-See also `Save`.
-END
-}
-op {
-  graph_op_name: "SaveV2"
-  endpoint {
-    name: "SaveV2"
-  }
-  summary: "Saves tensors in V2 checkpoint format."
-  description: <<END
-By default, saves the named tensors in full.  If the caller wishes to save
-specific slices of full tensors, "shape_and_slices" should be non-empty strings
-and correspondingly well-formed.
-END
-}
-op {
-  graph_op_name: "ScalarSummary"
-  endpoint {
-    name: "ScalarSummary"
-  }
-  summary: "Outputs a `Summary` protocol buffer with scalar values."
-  description: <<END
-The input `tags` and `values` must have the same shape.  The generated summary
-has a summary value for each tag-value pair in `tags` and `values`.
-END
-}
-op {
-  graph_op_name: "ScatterAdd"
-  endpoint {
-    name: "ScatterAdd"
-  }
-  summary: "Adds sparse updates to a variable reference."
-  description: <<END
-This operation computes
-
-    # Scalar indices
-    ref[indices, ...] += updates[...]
-
-    # Vector indices (for each i)
-    ref[indices[i], ...] += updates[i, ...]
-
-    # High rank indices (for each i, ..., j)
-    ref[indices[i, ..., j], ...] += updates[i, ..., j, ...]
-
-This operation outputs `ref` after the update is done.
-This makes it easier to chain operations that need to use the reset value.
-
-Duplicate entries are handled correctly: if multiple `indices` reference
-the same location, their contributions add.
-
-Requires `updates.shape = indices.shape + ref.shape[1:]`.
-
-<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-<img style="width:100%" src="https://www.tensorflow.org/images/ScatterAdd.png" alt>
-</div>
-END
-}
-op {
-  graph_op_name: "ScatterDiv"
-  endpoint {
-    name: "ScatterDiv"
-  }
-  summary: "Divides a variable reference by sparse updates."
-  description: <<END
-This operation computes
-
-```python
-    # Scalar indices
-    ref[indices, ...] /= updates[...]
-
-    # Vector indices (for each i)
-    ref[indices[i], ...] /= updates[i, ...]
-
-    # High rank indices (for each i, ..., j)
-    ref[indices[i, ..., j], ...] /= updates[i, ..., j, ...]
-```
-
-This operation outputs `ref` after the update is done.
-This makes it easier to chain operations that need to use the reset value.
-
-Duplicate entries are handled correctly: if multiple `indices` reference
-the same location, their contributions divide.
-
-Requires `updates.shape = indices.shape + ref.shape[1:]`.
-END
-}
-op {
-  graph_op_name: "ScatterMul"
-  endpoint {
-    name: "ScatterMul"
-  }
-  summary: "Multiplies sparse updates into a variable reference."
-  description: <<END
-This operation computes
-
-```python
-    # Scalar indices
-    ref[indices, ...] *= updates[...]
-
-    # Vector indices (for each i)
-    ref[indices[i], ...] *= updates[i, ...]
-
-    # High rank indices (for each i, ..., j)
-    ref[indices[i, ..., j], ...] *= updates[i, ..., j, ...]
-```
-
-This operation outputs `ref` after the update is done.
-This makes it easier to chain operations that need to use the reset value.
-
-Duplicate entries are handled correctly: if multiple `indices` reference
-the same location, their contributions multiply.
-
-Requires `updates.shape = indices.shape + ref.shape[1:]`.
-END
-}
-op {
-  graph_op_name: "ScatterNd"
-  endpoint {
-    name: "ScatterNd"
-  }
-  summary: "Scatter `updates` into a new (initially zero) tensor according to `indices`."
-  description: <<END
-Creates a new tensor by applying sparse `updates` to individual
-values or slices within a zero tensor of the given `shape` according to
-indices.  This operator is the inverse of the @{tf.gather_nd} operator which
-extracts values or slices from a given tensor.
-
-**WARNING**: The order in which updates are applied is nondeterministic, so the
-output will be nondeterministic if `indices` contains duplicates.
-
-`indices` is an integer tensor containing indices into a new tensor of shape
-`shape`.  The last dimension of `indices` can be at most the rank of `shape`:
-
-    indices.shape[-1] <= shape.rank
-
-The last dimension of `indices` corresponds to indices into elements
-(if `indices.shape[-1] = shape.rank`) or slices
-(if `indices.shape[-1] < shape.rank`) along dimension `indices.shape[-1]` of
-`shape`.  `updates` is a tensor with shape
-
-    indices.shape[:-1] + shape[indices.shape[-1]:]
-
-The simplest form of scatter is to insert individual elements in a tensor by
-index. For example, say we want to insert 4 scattered elements in a rank-1
-tensor with 8 elements.
-
-<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-<img style="width:100%" src="https://www.tensorflow.org/images/ScatterNd1.png" alt>
-</div>
-
-In Python, this scatter operation would look like this:
-
-```python
-    indices = tf.constant([[4], [3], [1], [7]])
-    updates = tf.constant([9, 10, 11, 12])
-    shape = tf.constant([8])
-    scatter = tf.scatter_nd(indices, updates, shape)
-    with tf.Session() as sess:
-      print(sess.run(scatter))
-```
-
-The resulting tensor would look like this:
-
-    [0, 11, 0, 10, 9, 0, 0, 12]
-
-We can also, insert entire slices of a higher rank tensor all at once. For
-example, if we wanted to insert two slices in the first dimension of a
-rank-3 tensor with two matrices of new values.
-
-<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-<img style="width:100%" src="https://www.tensorflow.org/images/ScatterNd2.png" alt>
-</div>
-
-In Python, this scatter operation would look like this:
-
-```python
-    indices = tf.constant([[0], [2]])
-    updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
-                            [7, 7, 7, 7], [8, 8, 8, 8]],
-                           [[5, 5, 5, 5], [6, 6, 6, 6],
-                            [7, 7, 7, 7], [8, 8, 8, 8]]])
-    shape = tf.constant([4, 4, 4])
-    scatter = tf.scatter_nd(indices, updates, shape)
-    with tf.Session() as sess:
-      print(sess.run(scatter))
-```
-
-The resulting tensor would look like this:
-
-    [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
-     [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]],
-     [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
-     [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]]
-END
-}
-op {
-  graph_op_name: "ScatterNdAdd"
-  endpoint {
-    name: "ScatterNdAdd"
-  }
-  summary: "Applies sparse addition between `updates` and individual values or slices"
-  description: <<END
-within a given variable according to `indices`.
-
-`ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
-
-`indices` must be integer tensor, containing indices into `ref`.
-It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
-
-The innermost dimension of `indices` (with length `K`) corresponds to
-indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
-dimension of `ref`.
-
-`updates` is `Tensor` of rank `Q-1+P-K` with shape:
-
-```
-[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
-```
-
-For example, say we want to add 4 scattered elements to a rank-1 tensor to 8
-elements. In Python, that addition would look like this:
-
-    ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
-    indices = tf.constant([[4], [3], [1], [7]])
-    updates = tf.constant([9, 10, 11, 12])
-    add = tf.scatter_nd_add(ref, indices, updates)
-    with tf.Session() as sess:
-      print sess.run(add)
-
-The resulting update to ref would look like this:
-
-    [1, 13, 3, 14, 14, 6, 7, 20]
-
-See @{tf.scatter_nd} for more details about how to make updates to
-slices.
-END
-}
-op {
-  graph_op_name: "ScatterNdNonAliasingAdd"
-  endpoint {
-    name: "ScatterNdNonAliasingAdd"
-  }
-  summary: "Applies sparse addition to `input` using individual values or slices"
-  description: <<END
-from `updates` according to indices `indices`.  The updates are non-aliasing:
-`input` is only modified in-place if no other operations will use it.
-Otherwise, a copy of `input` is made.  This operation has a gradient with
-respect to both `input` and `updates`.
-
-`input` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
-
-`indices` must be integer tensor, containing indices into `input`.
-It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
-
-The innermost dimension of `indices` (with length `K`) corresponds to
-indices into elements (if `K = P`) or `(P-K)`-dimensional slices
-(if `K < P`) along the `K`th dimension of `input`.
-
-`updates` is `Tensor` of rank `Q-1+P-K` with shape:
-
-```
-[d_0, ..., d_{Q-2}, input.shape[K], ..., input.shape[P-1]].
-```
-
-For example, say we want to add 4 scattered elements to a rank-1 tensor to 8
-elements. In Python, that addition would look like this:
-
-    input = tf.constant([1, 2, 3, 4, 5, 6, 7, 8])
-    indices = tf.constant([[4], [3], [1], [7]])
-    updates = tf.constant([9, 10, 11, 12])
-    output = tf.scatter_nd_non_aliasing_add(input, indices, updates)
-    with tf.Session() as sess:
-      print(sess.run(output))
-
-The resulting value `output` would look like this:
-
-    [1, 13, 3, 14, 14, 6, 7, 20]
-
-See @{tf.scatter_nd} for more details about how to make updates to slices.
-END
-}
-op {
-  graph_op_name: "ScatterNdSub"
-  endpoint {
-    name: "ScatterNdSub"
-  }
-  summary: "Applies sparse subtraction between `updates` and individual values or slices"
-  description: <<END
-within a given variable according to `indices`.
-
-`ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
-
-`indices` must be integer tensor, containing indices into `ref`.
-It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
-
-The innermost dimension of `indices` (with length `K`) corresponds to
-indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
-dimension of `ref`.
-
-`updates` is `Tensor` of rank `Q-1+P-K` with shape:
-
-```
-[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
-```
-
-For example, say we want to subtract 4 scattered elements from a rank-1 tensor
-with 8 elements. In Python, that subtraction would look like this:
-
-    ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
-    indices = tf.constant([[4], [3], [1], [7]])
-    updates = tf.constant([9, 10, 11, 12])
-    sub = tf.scatter_nd_sub(ref, indices, updates)
-    with tf.Session() as sess:
-      print sess.run(sub)
-
-The resulting update to ref would look like this:
-
-    [1, -9, 3, -6, -4, 6, 7, -4]
-
-See @{tf.scatter_nd} for more details about how to make updates to
-slices.
-END
-}
-op {
-  graph_op_name: "ScatterNdUpdate"
-  endpoint {
-    name: "ScatterNdUpdate"
-  }
-  summary: "Applies sparse `updates` to individual values or slices within a given"
-  description: <<END
-variable according to `indices`.
-
-`ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
-
-`indices` must be integer tensor, containing indices into `ref`.
-It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
-
-The innermost dimension of `indices` (with length `K`) corresponds to
-indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
-dimension of `ref`.
-
-`updates` is `Tensor` of rank `Q-1+P-K` with shape:
-
-```
-[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
-```
-
-For example, say we want to update 4 scattered elements to a rank-1 tensor to
-8 elements. In Python, that update would look like this:
-
-```python
-    ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
-    indices = tf.constant([[4], [3], [1] ,[7]])
-    updates = tf.constant([9, 10, 11, 12])
-    update = tf.scatter_nd_update(ref, indices, updates)
-    with tf.Session() as sess:
-      print sess.run(update)
-```
-
-The resulting update to ref would look like this:
-
-    [1, 11, 3, 10, 9, 6, 7, 12]
-
-See @{tf.scatter_nd} for more details about how to make updates to
-slices.
-END
-}
-op {
-  graph_op_name: "ScatterSub"
-  endpoint {
-    name: "ScatterSub"
-  }
-  summary: "Subtracts sparse updates to a variable reference."
-  description: <<END
-```python
-    # Scalar indices
-    ref[indices, ...] -= updates[...]
-
-    # Vector indices (for each i)
-    ref[indices[i], ...] -= updates[i, ...]
-
-    # High rank indices (for each i, ..., j)
-    ref[indices[i, ..., j], ...] -= updates[i, ..., j, ...]
-```
-
-This operation outputs `ref` after the update is done.
-This makes it easier to chain operations that need to use the reset value.
-
-Duplicate entries are handled correctly: if multiple `indices` reference
-the same location, their (negated) contributions add.
-
-Requires `updates.shape = indices.shape + ref.shape[1:]`.
-
-<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-<img style="width:100%" src="https://www.tensorflow.org/images/ScatterSub.png" alt>
-</div>
-END
-}
-op {
-  graph_op_name: "ScatterUpdate"
-  endpoint {
-    name: "ScatterUpdate"
-  }
-  summary: "Applies sparse updates to a variable reference."
-  description: <<END
-This operation computes
-
-```python
-    # Scalar indices
-    ref[indices, ...] = updates[...]
-
-    # Vector indices (for each i)
-    ref[indices[i], ...] = updates[i, ...]
-
-    # High rank indices (for each i, ..., j)
-    ref[indices[i, ..., j], ...] = updates[i, ..., j, ...]
-```
-
-This operation outputs `ref` after the update is done.
-This makes it easier to chain operations that need to use the reset value.
-
-If values in `ref` is to be updated more than once, because there are
-duplicate entries in `indices`, the order at which the updates happen
-for each value is undefined.
-
-Requires `updates.shape = indices.shape + ref.shape[1:]`.
-
-<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-<img style="width:100%" src="https://www.tensorflow.org/images/ScatterUpdate.png" alt>
-</div>
-END
-}
-op {
-  graph_op_name: "SdcaFprint"
-  endpoint {
-    name: "SdcaFprint"
-  }
-  summary: "Computes fingerprints of the input strings."
-}
-op {
-  graph_op_name: "SdcaOptimizer"
-  endpoint {
-    name: "SdcaOptimizer"
-  }
-  summary: "Distributed version of Stochastic Dual Coordinate Ascent (SDCA) optimizer for"
-  description: <<END
-linear models with L1 + L2 regularization. As global optimization objective is
-strongly-convex, the optimizer optimizes the dual objective at each step. The
-optimizer applies each update one example at a time. Examples are sampled
-uniformly, and the optimizer is learning rate free and enjoys linear convergence
-rate.
-
-[Proximal Stochastic Dual Coordinate Ascent](http://arxiv.org/pdf/1211.2717v1.pdf).<br>
-Shai Shalev-Shwartz, Tong Zhang. 2012
-
-$$Loss Objective = \sum f_{i} (wx_{i}) + (l2 / 2) * |w|^2 + l1 * |w|$$
-
-[Adding vs. Averaging in Distributed Primal-Dual Optimization](http://arxiv.org/abs/1502.03508).<br>
-Chenxin Ma, Virginia Smith, Martin Jaggi, Michael I. Jordan,
-Peter Richtarik, Martin Takac. 2015
-
-[Stochastic Dual Coordinate Ascent with Adaptive Probabilities](https://arxiv.org/abs/1502.08053).<br>
-Dominik Csiba, Zheng Qu, Peter Richtarik. 2015
-END
-}
-op {
-  graph_op_name: "SdcaShrinkL1"
-  endpoint {
-    name: "SdcaShrinkL1"
-  }
-  summary: "Applies L1 regularization shrink step on the parameters."
-}
-op {
-  graph_op_name: "SegmentMax"
-  endpoint {
-    name: "SegmentMax"
-  }
-  summary: "Computes the maximum along segments of a tensor."
-  description: <<END
-Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
-segments.
-
-Computes a tensor such that
-\\(output_i = \max_j(data_j)\\) where `max` is over `j` such
-that `segment_ids[j] == i`.
-
-If the max is empty for a given segment ID `i`, `output[i] = 0`.
-
-<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-<img style="width:100%" src="https://www.tensorflow.org/images/SegmentMax.png" alt>
-</div>
-END
-}
-op {
-  graph_op_name: "SegmentMean"
-  endpoint {
-    name: "SegmentMean"
-  }
-  summary: "Computes the mean along segments of a tensor."
-  description: <<END
-Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
-segments.
-
-Computes a tensor such that
-\\(output_i = \frac{\sum_j data_j}{N}\\) where `mean` is
-over `j` such that `segment_ids[j] == i` and `N` is the total number of
-values summed.
-
-If the mean is empty for a given segment ID `i`, `output[i] = 0`.
-
-<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-<img style="width:100%" src="https://www.tensorflow.org/images/SegmentMean.png" alt>
-</div>
-END
-}
-op {
-  graph_op_name: "SegmentMin"
-  endpoint {
-    name: "SegmentMin"
-  }
-  summary: "Computes the minimum along segments of a tensor."
-  description: <<END
-Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
-segments.
-
-Computes a tensor such that
-\\(output_i = \min_j(data_j)\\) where `min` is over `j` such
-that `segment_ids[j] == i`.
-
-If the min is empty for a given segment ID `i`, `output[i] = 0`.
-
-<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-<img style="width:100%" src="https://www.tensorflow.org/images/SegmentMin.png" alt>
-</div>
-END
-}
-op {
-  graph_op_name: "SegmentProd"
-  endpoint {
-    name: "SegmentProd"
-  }
-  summary: "Computes the product along segments of a tensor."
-  description: <<END
-Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
-segments.
-
-Computes a tensor such that
-\\(output_i = \prod_j data_j\\) where the product is over `j` such
-that `segment_ids[j] == i`.
-
-If the product is empty for a given segment ID `i`, `output[i] = 1`.
-
-<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-<img style="width:100%" src="https://www.tensorflow.org/images/SegmentProd.png" alt>
-</div>
-END
-}
-op {
-  graph_op_name: "SegmentSum"
-  endpoint {
-    name: "SegmentSum"
-  }
-  summary: "Computes the sum along segments of a tensor."
-  description: <<END
-Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
-segments.
-
-Computes a tensor such that
-\\(output_i = \sum_j data_j\\) where sum is over `j` such
-that `segment_ids[j] == i`.
-
-If the sum is empty for a given segment ID `i`, `output[i] = 0`.
-
-<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-<img style="width:100%" src="https://www.tensorflow.org/images/SegmentSum.png" alt>
-</div>
-END
-}
-op {
-  graph_op_name: "Select"
-  endpoint {
-    name: "Select"
-  }
-  summary: "Selects elements from `t` or `e`, depending on `condition`."
-  description: <<END
-The `t`, and `e` tensors must all have the same shape, and the
-output will also have that shape.
-
-The `condition` tensor must be a scalar if `t` and `e` are scalars.
-If `t` and `e` are vectors or higher rank, then `condition` must be either a
-scalar, a vector with size matching the first dimension of `t`, or must have
-the same shape as `t`.
-
-The `condition` tensor acts as a mask that chooses, based on the value at each
-element, whether the corresponding element / row in the output should be
-taken from `t` (if true) or `e` (if false).
-
-If `condition` is a vector and `t` and `e` are higher rank matrices, then
-it chooses which row (outer dimension) to copy from `t` and `e`.
-If `condition` has the same shape as `t` and `e`, then it chooses which
-element to copy from `t` and `e`.
-
-For example:
-
-```python
-# 'condition' tensor is [[True,  False]
-#                        [False, True]]
-# 't' is [[1, 2],
-#         [3, 4]]
-# 'e' is [[5, 6],
-#         [7, 8]]
-select(condition, t, e)  # => [[1, 6], [7, 4]]
-
-
-# 'condition' tensor is [True, False]
-# 't' is [[1, 2],
-#         [3, 4]]
-# 'e' is [[5, 6],
-#         [7, 8]]
-select(condition, t, e) ==> [[1, 2],
-                             [7, 8]]
-
-```
-END
-}
-op {
-  graph_op_name: "SelfAdjointEig"
-  endpoint {
-    name: "SelfAdjointEig"
-  }
-  summary: "Computes the Eigen Decomposition of a batch of square self-adjoint matrices."
-  description: <<END
-The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
-form square matrices, with the same constraints as the single matrix
-SelfAdjointEig.
-
-The result is a [..., M+1, M] matrix with [..., 0,:] containing the
-eigenvalues, and subsequent [...,1:, :] containing the eigenvectors.
-END
-}
-op {
-  graph_op_name: "SelfAdjointEigV2"
-  endpoint {
-    name: "SelfAdjointEigV2"
-  }
-  summary: "Computes the eigen decomposition of one or more square self-adjoint matrices."
-  description: <<END
-Computes the eigenvalues and (optionally) eigenvectors of each inner matrix in
-`input` such that `input[..., :, :] = v[..., :, :] * diag(e[..., :])`.
-
-```python
-# a is a tensor.
-# e is a tensor of eigenvalues.
-# v is a tensor of eigenvectors.
-e, v = self_adjoint_eig(a)
-e = self_adjoint_eig(a, compute_v=False)
-```
-END
-}
-op {
-  graph_op_name: "Selu"
-  endpoint {
-    name: "Selu"
-  }
-  summary: "Computes scaled exponential linear: `scale * alpha * (exp(features) - 1)`"
-  description: <<END
-if < 0, `scale * features` otherwise.
-
-See [Self-Normalizing Neural Networks](https://arxiv.org/abs/1706.02515)
-END
-}
-op {
-  graph_op_name: "SeluGrad"
-  endpoint {
-    name: "SeluGrad"
-  }
-  summary: "Computes gradients for the scaled exponential linear (Selu) operation."
-}
-op {
-  graph_op_name: "SerializeManySparse"
-  endpoint {
-    name: "SerializeManySparse"
-  }
-  summary: "Serialize an `N`-minibatch `SparseTensor` into an `[N, 3]` string `Tensor`."
-  description: <<END
-The `SparseTensor` must have rank `R` greater than 1, and the first dimension
-is treated as the minibatch dimension.  Elements of the `SparseTensor`
-must be sorted in increasing order of this first dimension.  The serialized
-`SparseTensor` objects going into each row of `serialized_sparse` will have
-rank `R-1`.
-
-The minibatch size `N` is extracted from `sparse_shape[0]`.
-END
-}
-op {
-  graph_op_name: "SerializeSparse"
-  endpoint {
-    name: "SerializeSparse"
-  }
-  summary: "Serialize a `SparseTensor` into a string 3-vector (1-D `Tensor`) object."
-}
-op {
-  graph_op_name: "SerializeTensor"
-  endpoint {
-    name: "SerializeTensor"
-  }
-  summary: "Transforms a Tensor into a serialized TensorProto proto."
-}
-op {
-  graph_op_name: "SetSize"
-  endpoint {
-    name: "SetSize"
-  }
-  summary: "Number of unique elements along last dimension of input `set`."
-  description: <<END
-Input `set` is a `SparseTensor` represented by `set_indices`, `set_values`,
-and `set_shape`. The last dimension contains values in a set, duplicates are
-allowed but ignored.
-
-If `validate_indices` is `True`, this op validates the order and range of `set`
-indices.
-END
-}
-op {
-  graph_op_name: "Shape"
-  endpoint {
-    name: "Shape"
-  }
-  summary: "Returns the shape of a tensor."
-  description: <<END
-This operation returns a 1-D integer tensor representing the shape of `input`.
-
-For example:
-
-```
-# 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
-shape(t) ==> [2, 2, 3]
-```
-END
-}
-op {
-  graph_op_name: "ShapeN"
-  endpoint {
-    name: "ShapeN"
-  }
-  summary: "Returns shape of tensors."
-  description: <<END
-This operation returns N 1-D integer tensors representing shape of `input[i]s`.
-END
-}
-op {
-  graph_op_name: "ShardedFilename"
-  endpoint {
-    name: "ShardedFilename"
-  }
-  summary: "Generate a sharded filename. The filename is printf formatted as"
-  description: <<END
-   %s-%05d-of-%05d, basename, shard, num_shards.
-END
-}
-op {
-  graph_op_name: "ShardedFilespec"
-  endpoint {
-    name: "ShardedFilespec"
-  }
-  summary: "Generate a glob pattern matching all sharded file names."
-}
-op {
-  graph_op_name: "ShuffleDataset"
-  endpoint {
-    name: "ShuffleDataset"
-  }
-  summary: "Creates a dataset that shuffles elements from `input_dataset` pseudorandomly."
-}
-op {
-  graph_op_name: "Sigmoid"
-  endpoint {
-    name: "Sigmoid"
-  }
-  summary: "Computes sigmoid of `x` element-wise."
-  description: <<END
-Specifically, `y = 1 / (1 + exp(-x))`.
-END
-}
-op {
-  graph_op_name: "SigmoidGrad"
-  endpoint {
-    name: "SigmoidGrad"
-  }
-  summary: "Computes the gradient of the sigmoid of `x` wrt its input."
-  description: <<END
-Specifically, `grad = dy * y * (1 - y)`, where `y = sigmoid(x)`, and
-`dy` is the corresponding input gradient.
-END
-}
-op {
-  graph_op_name: "Sign"
-  endpoint {
-    name: "Sign"
-  }
-  summary: "Returns an element-wise indication of the sign of a number."
-  description: <<END
-`y = sign(x) = -1` if `x < 0`; 0 if `x == 0`; 1 if `x > 0`.
-
-For complex numbers, `y = sign(x) = x / |x|` if `x != 0`, otherwise `y = 0`.
-END
-}
-op {
-  graph_op_name: "Sin"
-  endpoint {
-    name: "Sin"
-  }
-  summary: "Computes sin of x element-wise."
-}
-op {
-  graph_op_name: "Sinh"
-  endpoint {
-    name: "Sinh"
-  }
-  summary: "Computes hyperbolic sine of x element-wise."
-}
-op {
-  graph_op_name: "Size"
-  endpoint {
-    name: "Size"
-  }
-  summary: "Returns the size of a tensor."
-  description: <<END
-This operation returns an integer representing the number of elements in
-`input`.
-
-For example:
-
-```
-# 't' is [[[1, 1,, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]]
-size(t) ==> 12
-```
-END
-}
-op {
-  graph_op_name: "SkipDataset"
-  endpoint {
-    name: "SkipDataset"
-  }
-  summary: "Creates a dataset that skips `count` elements from the `input_dataset`."
-}
-op {
-  graph_op_name: "Skipgram"
-  endpoint {
-    name: "Skipgram"
-  }
-  summary: "Parses a text file and creates a batch of examples."
-}
-op {
-  graph_op_name: "Slice"
-  endpoint {
-    name: "Slice"
-  }
-  summary: "Return a slice from \'input\'."
-  description: <<END
-The output tensor is a tensor with dimensions described by 'size'
-whose values are extracted from 'input' starting at the offsets in
-'begin'.
-
-*Requirements*:
-  0 <= begin[i] <= begin[i] + size[i] <= Di  for i in [0, n)
-END
-}
-op {
-  graph_op_name: "SloppyInterleaveDataset"
-  endpoint {
-    name: "SloppyInterleaveDataset"
-  }
-  summary: "Creates a dataset that applies `f` to the outputs of `input_dataset`."
-  description: <<END
-The resulting dataset is similar to the `InterleaveDataset`, with the exception
-that if retrieving the next value from a dataset would cause the requester to
-block, it will skip that input dataset. This dataset is especially useful
-when loading data from a variable-latency datastores (e.g. HDFS, GCS), as it
-allows the training step to proceed so long as some data is available.
-
-!! WARNING !! This dataset is not deterministic!
-END
-}
-op {
-  graph_op_name: "Softmax"
-  endpoint {
-    name: "Softmax"
-  }
-  summary: "Computes softmax activations."
-  description: <<END
-For each batch `i` and class `j` we have
-
-    softmax[i, j] = exp(logits[i, j]) / sum_j(exp(logits[i, j]))
-END
-}
-op {
-  graph_op_name: "SoftmaxCrossEntropyWithLogits"
-  endpoint {
-    name: "SoftmaxCrossEntropyWithLogits"
-  }
-  summary: "Computes softmax cross entropy cost and gradients to backpropagate."
-  description: <<END
-Inputs are the logits, not probabilities.
-END
-}
-op {
-  graph_op_name: "Softplus"
-  endpoint {
-    name: "Softplus"
-  }
-  summary: "Computes softplus: `log(exp(features) + 1)`."
-}
-op {
-  graph_op_name: "SoftplusGrad"
-  endpoint {
-    name: "SoftplusGrad"
-  }
-  summary: "Computes softplus gradients for a softplus operation."
-}
-op {
-  graph_op_name: "Softsign"
-  endpoint {
-    name: "Softsign"
-  }
-  summary: "Computes softsign: `features / (abs(features) + 1)`."
-}
-op {
-  graph_op_name: "SoftsignGrad"
-  endpoint {
-    name: "SoftsignGrad"
-  }
-  summary: "Computes softsign gradients for a softsign operation."
-}
-op {
-  graph_op_name: "SpaceToBatch"
-  endpoint {
-    name: "SpaceToBatch"
-  }
-  summary: "SpaceToBatch for 4-D tensors of type T."
-  description: <<END
-This is a legacy version of the more general SpaceToBatchND.
-
-Zero-pads and then rearranges (permutes) blocks of spatial data into batch.
-More specifically, this op outputs a copy of the input tensor where values from
-the `height` and `width` dimensions are moved to the `batch` dimension. After
-the zero-padding, both `height` and `width` of the input must be divisible by the
-block size.
-END
-}
-op {
-  graph_op_name: "SpaceToBatchND"
-  endpoint {
-    name: "SpaceToBatchND"
-  }
-  summary: "SpaceToBatch for N-D tensors of type T."
-  description: <<END
-This operation divides "spatial" dimensions `[1, ..., M]` of the input into a
-grid of blocks of shape `block_shape`, and interleaves these blocks with the
-"batch" dimension (0) such that in the output, the spatial dimensions
-`[1, ..., M]` correspond to the position within the grid, and the batch
-dimension combines both the position within a spatial block and the original
-batch position.  Prior to division into blocks, the spatial dimensions of the
-input are optionally zero padded according to `paddings`.  See below for a
-precise description.
-END
-}
-op {
-  graph_op_name: "SpaceToDepth"
-  endpoint {
-    name: "SpaceToDepth"
-  }
-  summary: "SpaceToDepth for tensors of type T."
-  description: <<END
-Rearranges blocks of spatial data, into depth. More specifically,
-this op outputs a copy of the input tensor where values from the `height`
-and `width` dimensions are moved to the `depth` dimension.
-The attr `block_size` indicates the input block size.
-
-  * Non-overlapping blocks of size `block_size x block size` are rearranged
-    into depth at each location.
-  * The depth of the output tensor is `block_size * block_size * input_depth`.
-  * The Y, X coordinates within each block of the input become the high order
-    component of the output channel index.
-  * The input tensor's height and width must be divisible by block_size.
-
-The `data_format` attr specifies the layout of the input and output tensors
-with the following options:
-  "NHWC": `[ batch, height, width, channels ]`
-  "NCHW": `[ batch, channels, height, width ]`
-  "NCHW_VECT_C":
-      `qint8 [ batch, channels / 4, height, width, channels % 4 ]`
-
-It is useful to consider the operation as transforming a 6-D Tensor.
-e.g. for data_format = NHWC,
-     Each element in the input tensor can be specified via 6 coordinates,
-     ordered by decreasing memory layout significance as:
-     n,oY,bY,oX,bX,iC  (where n=batch index, oX, oY means X or Y coordinates
-                        within the output image, bX, bY means coordinates
-                        within the input block, iC means input channels).
-     The output would be a transpose to the following layout:
-     n,oY,oX,bY,bX,iC
-
-This operation is useful for resizing the activations between convolutions
-(but keeping all data), e.g. instead of pooling. It is also useful for training
-purely convolutional models.
-
-For example, given an input of shape `[1, 2, 2, 1]`, data_format = "NHWC" and
-block_size = 2:
-
-```
-x = [[[[1], [2]],
-      [[3], [4]]]]
-```
-
-This operation will output a tensor of shape `[1, 1, 1, 4]`:
-
-```
-[[[[1, 2, 3, 4]]]]
-```
-
-Here, the input has a batch of 1 and each batch element has shape `[2, 2, 1]`,
-the corresponding output will have a single element (i.e. width and height are
-both 1) and will have a depth of 4 channels (1 * block_size * block_size).
-The output element shape is `[1, 1, 4]`.
-
-For an input tensor with larger depth, here of shape `[1, 2, 2, 3]`, e.g.
-
-```
-x = [[[[1, 2, 3], [4, 5, 6]],
-      [[7, 8, 9], [10, 11, 12]]]]
-```
-
-This operation, for block_size of 2, will return the following tensor of shape
-`[1, 1, 1, 12]`
-
-```
-[[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
-```
-
-Similarly, for the following input of shape `[1 4 4 1]`, and a block size of 2:
-
-```
-x = [[[[1],   [2],  [5],  [6]],
-      [[3],   [4],  [7],  [8]],
-      [[9],  [10], [13],  [14]],
-      [[11], [12], [15],  [16]]]]
-```
-
-the operator will return the following tensor of shape `[1 2 2 4]`:
-
-```
-x = [[[[1, 2, 3, 4],
-       [5, 6, 7, 8]],
-      [[9, 10, 11, 12],
-       [13, 14, 15, 16]]]]
-```
-END
-}
-op {
-  graph_op_name: "SparseAccumulatorApplyGradient"
-  endpoint {
-    name: "SparseAccumulatorApplyGradient"
-  }
-  summary: "Applies a sparse gradient to a given accumulator."
-  description: <<END
-Does not add if local_step is smaller than the accumulator's
-global_step.
-END
-}
-op {
-  graph_op_name: "SparseAccumulatorTakeGradient"
-  endpoint {
-    name: "SparseAccumulatorTakeGradient"
-  }
-  summary: "Extracts the average sparse gradient in a SparseConditionalAccumulator."
-  description: <<END
-The op will blocks until sufficient (i.e., more than num_required)
-gradients have been accumulated. If the accumulator has already
-aggregated more than num_required gradients, it will return its
-average of the accumulated gradients.  Also automatically increments
-the recorded global_step in the accumulator by 1, and resets the
-aggregate to 0.
-END
-}
-op {
-  graph_op_name: "SparseAdd"
-  endpoint {
-    name: "SparseAdd"
-  }
-  summary: "Adds two `SparseTensor` objects to produce another `SparseTensor`."
-  description: <<END
-The input `SparseTensor` objects' indices are assumed ordered in standard
-lexicographic order.  If this is not the case, before this step run
-`SparseReorder` to restore index ordering.
-
-By default, if two values sum to zero at some index, the output `SparseTensor`
-would still include that particular location in its index, storing a zero in the
-corresponding value slot.  To override this, callers can specify `thresh`,
-indicating that if the sum has a magnitude strictly smaller than `thresh`, its
-corresponding value and index would then not be included.  In particular,
-`thresh == 0` (default) means everything is kept and actual thresholding happens
-only for a positive value.
-
-In the following shapes, `nnz` is the count after taking `thresh` into account.
-END
-}
-op {
-  graph_op_name: "SparseAddGrad"
-  endpoint {
-    name: "SparseAddGrad"
-  }
-  summary: "The gradient operator for the SparseAdd op."
-  description: <<END
-The SparseAdd op calculates A + B, where A, B, and the sum are all represented
-as `SparseTensor` objects.  This op takes in the upstream gradient w.r.t.
-non-empty values of the sum, and outputs the gradients w.r.t. the non-empty
-values of A and B.
-END
-}
-op {
-  graph_op_name: "SparseApplyAdadelta"
-  endpoint {
-    name: "SparseApplyAdadelta"
-  }
-  summary: "var: Should be from a Variable()."
-}
-op {
-  graph_op_name: "SparseApplyAdagrad"
-  endpoint {
-    name: "SparseApplyAdagrad"
-  }
-  summary: "Update relevant entries in \'*var\' and \'*accum\' according to the adagrad scheme."
-  description: <<END
-That is for rows we have grad for, we update var and accum as follows:
-accum += grad * grad
-var -= lr * grad * (1 / sqrt(accum))
-END
-}
-op {
-  graph_op_name: "SparseApplyAdagradDA"
-  endpoint {
-    name: "SparseApplyAdagradDA"
-  }
-  summary: "Update entries in \'*var\' and \'*accum\' according to the proximal adagrad scheme."
-}
-op {
-  graph_op_name: "SparseApplyCenteredRMSProp"
-  endpoint {
-    name: "SparseApplyCenteredRMSProp"
-  }
-  summary: "Update \'*var\' according to the centered RMSProp algorithm."
-  description: <<END
-The centered RMSProp algorithm uses an estimate of the centered second moment
-(i.e., the variance) for normalization, as opposed to regular RMSProp, which
-uses the (uncentered) second moment. This often helps with training, but is
-slightly more expensive in terms of computation and memory.
-
-Note that in dense implementation of this algorithm, mg, ms, and mom will
-update even if the grad is zero, but in this sparse implementation, mg, ms,
-and mom will not update in iterations during which the grad is zero.
-
-mean_square = decay * mean_square + (1-decay) * gradient ** 2
-mean_grad = decay * mean_grad + (1-decay) * gradient
-Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2)
-
-ms <- rho * ms_{t-1} + (1-rho) * grad * grad
-mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
-var <- var - mom
-END
-}
-op {
-  graph_op_name: "SparseApplyFtrl"
-  endpoint {
-    name: "SparseApplyFtrl"
-  }
-  summary: "Update relevant entries in \'*var\' according to the Ftrl-proximal scheme."
-  description: <<END
-That is for rows we have grad for, we update var, accum and linear as follows:
-accum_new = accum + grad * grad
-linear += grad + (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
-quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
-var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
-accum = accum_new
-END
-}
-op {
-  graph_op_name: "SparseApplyFtrlV2"
-  endpoint {
-    name: "SparseApplyFtrlV2"
-  }
-  summary: "Update relevant entries in \'*var\' according to the Ftrl-proximal scheme."
-  description: <<END
-That is for rows we have grad for, we update var, accum and linear as follows:
-grad_with_shrinkage = grad + 2 * l2_shrinkage * var
-accum_new = accum + grad_with_shrinkage * grad_with_shrinkage
-linear += grad_with_shrinkage +
-    (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
-quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
-var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
-accum = accum_new
-END
-}
-op {
-  graph_op_name: "SparseApplyMomentum"
-  endpoint {
-    name: "SparseApplyMomentum"
-  }
-  summary: "Update relevant entries in \'*var\' and \'*accum\' according to the momentum scheme."
-  description: <<END
-Set use_nesterov = True if you want to use Nesterov momentum.
-
-That is for rows we have grad for, we update var and accum as follows:
-
-accum = accum * momentum + grad
-var -= lr * accum
-END
-}
-op {
-  graph_op_name: "SparseApplyProximalAdagrad"
-  endpoint {
-    name: "SparseApplyProximalAdagrad"
-  }
-  summary: "Sparse update entries in \'*var\' and \'*accum\' according to FOBOS algorithm."
-  description: <<END
-That is for rows we have grad for, we update var and accum as follows:
-accum += grad * grad
-prox_v = var
-prox_v -= lr * grad * (1 / sqrt(accum))
-var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}
-END
-}
-op {
-  graph_op_name: "SparseApplyProximalGradientDescent"
-  endpoint {
-    name: "SparseApplyProximalGradientDescent"
-  }
-  summary: "Sparse update \'*var\' as FOBOS algorithm with fixed learning rate."
-  description: <<END
-That is for rows we have grad for, we update var as follows:
-prox_v = var - alpha * grad
-var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}
-END
-}
-op {
-  graph_op_name: "SparseApplyRMSProp"
-  endpoint {
-    name: "SparseApplyRMSProp"
-  }
-  summary: "Update \'*var\' according to the RMSProp algorithm."
-  description: <<END
-Note that in dense implementation of this algorithm, ms and mom will
-update even if the grad is zero, but in this sparse implementation, ms
-and mom will not update in iterations during which the grad is zero.
-
-mean_square = decay * mean_square + (1-decay) * gradient ** 2
-Delta = learning_rate * gradient / sqrt(mean_square + epsilon)
-
-ms <- rho * ms_{t-1} + (1-rho) * grad * grad
-mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
-var <- var - mom
-END
-}
-op {
-  graph_op_name: "SparseConcat"
-  endpoint {
-    name: "SparseConcat"
-  }
-  summary: "Concatenates a list of `SparseTensor` along the specified dimension."
-  description: <<END
-Concatenation is with respect to the dense versions of these sparse tensors.
-It is assumed that each input is a `SparseTensor` whose elements are ordered
-along increasing dimension number.
-
-All inputs' shapes must match, except for the concat dimension.  The
-`indices`, `values`, and `shapes` lists must have the same length.
-
-The output shape is identical to the inputs', except along the concat
-dimension, where it is the sum of the inputs' sizes along that dimension.
-
-The output elements will be resorted to preserve the sort order along
-increasing dimension number.
-
-This op runs in `O(M log M)` time, where `M` is the total number of non-empty
-values across all inputs. This is due to the need for an internal sort in
-order to concatenate efficiently across an arbitrary dimension.
-
-For example, if `concat_dim = 1` and the inputs are
-
-    sp_inputs[0]: shape = [2, 3]
-    [0, 2]: "a"
-    [1, 0]: "b"
-    [1, 1]: "c"
-
-    sp_inputs[1]: shape = [2, 4]
-    [0, 1]: "d"
-    [0, 2]: "e"
-
-then the output will be
-
-    shape = [2, 7]
-    [0, 2]: "a"
-    [0, 4]: "d"
-    [0, 5]: "e"
-    [1, 0]: "b"
-    [1, 1]: "c"
-
-Graphically this is equivalent to doing
-
-    [    a] concat [  d e  ] = [    a   d e  ]
-    [b c  ]        [       ]   [b c          ]
-END
-}
-op {
-  graph_op_name: "SparseConditionalAccumulator"
-  endpoint {
-    name: "SparseConditionalAccumulator"
-  }
-  summary: "A conditional accumulator for aggregating sparse gradients."
-  description: <<END
-The accumulator accepts gradients marked with local_step greater or
-equal to the most recent global_step known to the accumulator. The
-average can be extracted from the accumulator, provided sufficient
-gradients have been accumulated. Extracting the average automatically
-resets the aggregate to 0, and increments the global_step recorded by
-the accumulator.
-END
-}
-op {
-  graph_op_name: "SparseCross"
-  endpoint {
-    name: "SparseCross"
-  }
-  summary: "Generates sparse cross from a list of sparse and dense tensors."
-  description: <<END
-The op takes two lists, one of 2D `SparseTensor` and one of 2D `Tensor`, each
-representing features of one feature column. It outputs a 2D `SparseTensor` with
-the batchwise crosses of these features.
-
-For example, if the inputs are
-
-    inputs[0]: SparseTensor with shape = [2, 2]
-    [0, 0]: "a"
-    [1, 0]: "b"
-    [1, 1]: "c"
-
-    inputs[1]: SparseTensor with shape = [2, 1]
-    [0, 0]: "d"
-    [1, 0]: "e"
-
-    inputs[2]: Tensor [["f"], ["g"]]
-
-then the output will be
-
-    shape = [2, 2]
-    [0, 0]: "a_X_d_X_f"
-    [1, 0]: "b_X_e_X_g"
-    [1, 1]: "c_X_e_X_g"
-
-if hashed_output=true then the output will be
-
-    shape = [2, 2]
-    [0, 0]: FingerprintCat64(
-                Fingerprint64("f"), FingerprintCat64(
-                    Fingerprint64("d"), Fingerprint64("a")))
-    [1, 0]: FingerprintCat64(
-                Fingerprint64("g"), FingerprintCat64(
-                    Fingerprint64("e"), Fingerprint64("b")))
-    [1, 1]: FingerprintCat64(
-                Fingerprint64("g"), FingerprintCat64(
-                    Fingerprint64("e"), Fingerprint64("c")))
-END
-}
-op {
-  graph_op_name: "SparseDenseCwiseAdd"
-  endpoint {
-    name: "SparseDenseCwiseAdd"
-  }
-  summary: "Adds up a SparseTensor and a dense Tensor, using these special rules:"
-  description: <<END
-(1) Broadcasts the dense side to have the same shape as the sparse side, if
-    eligible;
-(2) Then, only the dense values pointed to by the indices of the SparseTensor
-    participate in the cwise addition.
-
-By these rules, the result is a logical SparseTensor with exactly the same
-indices and shape, but possibly with different non-zero values.  The output of
-this Op is the resultant non-zero values.
-END
-}
-op {
-  graph_op_name: "SparseDenseCwiseDiv"
-  endpoint {
-    name: "SparseDenseCwiseDiv"
-  }
-  summary: "Component-wise divides a SparseTensor by a dense Tensor."
-  description: <<END
-*Limitation*: this Op only broadcasts the dense side to the sparse side, but not
-the other direction.
-END
-}
-op {
-  graph_op_name: "SparseDenseCwiseMul"
-  endpoint {
-    name: "SparseDenseCwiseMul"
-  }
-  summary: "Component-wise multiplies a SparseTensor by a dense Tensor."
-  description: <<END
-The output locations corresponding to the implicitly zero elements in the sparse
-tensor will be zero (i.e., will not take up storage space), regardless of the
-contents of the dense tensor (even if it's +/-INF and that INF*0 == NaN).
-
-*Limitation*: this Op only broadcasts the dense side to the sparse side, but not
-the other direction.
-END
-}
-op {
-  graph_op_name: "SparseFillEmptyRows"
-  endpoint {
-    name: "SparseFillEmptyRows"
-  }
-  summary: "Fills empty rows in the input 2-D `SparseTensor` with a default value."
-  description: <<END
-The input `SparseTensor` is represented via the tuple of inputs
-(`indices`, `values`, `dense_shape`).  The output `SparseTensor` has the
-same `dense_shape` but with indices `output_indices` and values
-`output_values`.
-
-This op inserts a single entry for every row that doesn't have any values.
-The index is created as `[row, 0, ..., 0]` and the inserted value
-is `default_value`.
-
-For example, suppose `sp_input` has shape `[5, 6]` and non-empty values:
-
-    [0, 1]: a
-    [0, 3]: b
-    [2, 0]: c
-    [3, 1]: d
-
-Rows 1 and 4 are empty, so the output will be of shape `[5, 6]` with values:
-
-    [0, 1]: a
-    [0, 3]: b
-    [1, 0]: default_value
-    [2, 0]: c
-    [3, 1]: d
-    [4, 0]: default_value
-
-The output `SparseTensor` will be in row-major order and will have the
-same shape as the input.
-
-This op also returns an indicator vector shaped `[dense_shape[0]]` such that
-
-    empty_row_indicator[i] = True iff row i was an empty row.
-
-And a reverse index map vector shaped `[indices.shape[0]]` that is used during
-backpropagation,
-
-    reverse_index_map[j] = out_j s.t. indices[j, :] == output_indices[out_j, :]
-END
-}
-op {
-  graph_op_name: "SparseFillEmptyRowsGrad"
-  endpoint {
-    name: "SparseFillEmptyRowsGrad"
-  }
-  summary: "The gradient of SparseFillEmptyRows."
-  description: <<END
-Takes vectors reverse_index_map, shaped `[N]`, and grad_values,
-shaped `[N_full]`, where `N_full >= N` and copies data into either
-`d_values` or `d_default_value`.  Here `d_values` is shaped `[N]` and
-`d_default_value` is a scalar.
-
-  d_values[j] = grad_values[reverse_index_map[j]]
-  d_default_value = sum_{k : 0 .. N_full - 1} (
-     grad_values[k] * 1{k not in reverse_index_map})
-END
-}
-op {
-  graph_op_name: "SparseMatMul"
-  endpoint {
-    name: "SparseMatMul"
-  }
-  summary: "Multiply matrix \"a\" by matrix \"b\"."
-  description: <<END
-The inputs must be two-dimensional matrices and the inner dimension of "a" must
-match the outer dimension of "b". This op is optimized for the case where at
-least one of "a" or "b" is sparse. The breakeven for using this versus a dense
-matrix multiply on one platform was 30% zero values in the sparse matrix.
-
-The gradient computation of this operation will only take advantage of sparsity
-in the input gradient when that gradient comes from a Relu.
-END
-}
-op {
-  graph_op_name: "SparseReduceMax"
-  endpoint {
-    name: "SparseReduceMax"
-  }
-  summary: "Computes the max of elements across dimensions of a SparseTensor."
-  description: <<END
-This Op takes a SparseTensor and is the sparse counterpart to
-`tf.reduce_max()`.  In particular, this Op also returns a dense `Tensor`
-instead of a sparse one.
-
-Reduces `sp_input` along the dimensions given in `reduction_axes`.  Unless
-`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-`reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
-with length 1.
-
-If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
-with a single element is returned.  Additionally, the axes can be negative,
-which are interpreted according to the indexing rules in Python.
-END
-}
-op {
-  graph_op_name: "SparseReduceMaxSparse"
-  endpoint {
-    name: "SparseReduceMaxSparse"
-  }
-  summary: "Computes the max of elements across dimensions of a SparseTensor."
-  description: <<END
-This Op takes a SparseTensor and is the sparse counterpart to
-`tf.reduce_max()`.  In contrast to SparseReduceMax, this Op returns a
-SparseTensor.
-
-Reduces `sp_input` along the dimensions given in `reduction_axes`.  Unless
-`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-`reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
-with length 1.
-
-If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
-with a single element is returned.  Additionally, the axes can be negative,
-which are interpreted according to the indexing rules in Python.
-END
-}
-op {
-  graph_op_name: "SparseReduceSum"
-  endpoint {
-    name: "SparseReduceSum"
-  }
-  summary: "Computes the sum of elements across dimensions of a SparseTensor."
-  description: <<END
-This Op takes a SparseTensor and is the sparse counterpart to
-`tf.reduce_sum()`.  In particular, this Op also returns a dense `Tensor`
-instead of a sparse one.
-
-Reduces `sp_input` along the dimensions given in `reduction_axes`.  Unless
-`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-`reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
-with length 1.
-
-If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
-with a single element is returned.  Additionally, the axes can be negative,
-which are interpreted according to the indexing rules in Python.
-END
-}
-op {
-  graph_op_name: "SparseReduceSumSparse"
-  endpoint {
-    name: "SparseReduceSumSparse"
-  }
-  summary: "Computes the sum of elements across dimensions of a SparseTensor."
-  description: <<END
-This Op takes a SparseTensor and is the sparse counterpart to
-`tf.reduce_sum()`.  In contrast to SparseReduceSum, this Op returns a
-SparseTensor.
-
-Reduces `sp_input` along the dimensions given in `reduction_axes`.  Unless
-`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-`reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
-with length 1.
-
-If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
-with a single element is returned.  Additionally, the axes can be negative,
-which are interpreted according to the indexing rules in Python.
-END
-}
-op {
-  graph_op_name: "SparseReorder"
-  endpoint {
-    name: "SparseReorder"
-  }
-  summary: "Reorders a SparseTensor into the canonical, row-major ordering."
-  description: <<END
-Note that by convention, all sparse ops preserve the canonical ordering along
-increasing dimension number. The only time ordering can be violated is during
-manual manipulation of the indices and values vectors to add entries.
-
-Reordering does not affect the shape of the SparseTensor.
-
-If the tensor has rank `R` and `N` non-empty values, `input_indices` has
-shape `[N, R]`, input_values has length `N`, and input_shape has length `R`.
-END
-}
-op {
-  graph_op_name: "SparseReshape"
-  endpoint {
-    name: "SparseReshape"
-  }
-  summary: "Reshapes a SparseTensor to represent values in a new dense shape."
-  description: <<END
-This operation has the same semantics as reshape on the represented dense
-tensor.  The `input_indices` are recomputed based on the requested `new_shape`.
-
-If one component of `new_shape` is the special value -1, the size of that
-dimension is computed so that the total dense size remains constant.  At
-most one component of `new_shape` can be -1.  The number of dense elements
-implied by `new_shape` must be the same as the number of dense elements
-originally implied by `input_shape`.
-
-Reshaping does not affect the order of values in the SparseTensor.
-
-If the input tensor has rank `R_in` and `N` non-empty values, and `new_shape`
-has length `R_out`, then `input_indices` has shape `[N, R_in]`,
-`input_shape` has length `R_in`, `output_indices` has shape `[N, R_out]`, and
-`output_shape` has length `R_out`.
-END
-}
-op {
-  graph_op_name: "SparseSegmentMean"
-  endpoint {
-    name: "SparseSegmentMean"
-  }
-  summary: "Computes the mean along sparse segments of a tensor."
-  description: <<END
-Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
-segments.
-
-Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first
-dimension, selecting a subset of dimension 0, specified by `indices`.
-END
-}
-op {
-  graph_op_name: "SparseSegmentMeanGrad"
-  endpoint {
-    name: "SparseSegmentMeanGrad"
-  }
-  summary: "Computes gradients for SparseSegmentMean."
-  description: <<END
-Returns tensor "output" with same shape as grad, except for dimension 0 whose
-value is output_dim0.
-END
-}
-op {
-  graph_op_name: "SparseSegmentSqrtN"
-  endpoint {
-    name: "SparseSegmentSqrtN"
-  }
-  summary: "Computes the sum along sparse segments of a tensor divided by the sqrt of N."
-  description: <<END
-N is the size of the segment being reduced.
-
-Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
-segments.
-END
-}
-op {
-  graph_op_name: "SparseSegmentSqrtNGrad"
-  endpoint {
-    name: "SparseSegmentSqrtNGrad"
-  }
-  summary: "Computes gradients for SparseSegmentSqrtN."
-  description: <<END
-Returns tensor "output" with same shape as grad, except for dimension 0 whose
-value is output_dim0.
-END
-}
-op {
-  graph_op_name: "SparseSegmentSum"
-  endpoint {
-    name: "SparseSegmentSum"
-  }
-  summary: "Computes the sum along sparse segments of a tensor."
-  description: <<END
-Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
-segments.
-
-Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first
-dimension, selecting a subset of dimension 0, specified by `indices`.
-
-For example:
-
-```python
-c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
-
-# Select two rows, one segment.
-tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))
-# => [[0 0 0 0]]
-
-# Select two rows, two segment.
-tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))
-# => [[ 1  2  3  4]
-#     [-1 -2 -3 -4]]
-
-# Select all rows, two segments.
-tf.sparse_segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))
-# => [[0 0 0 0]
-#     [5 6 7 8]]
-
-# Which is equivalent to:
-tf.segment_sum(c, tf.constant([0, 0, 1]))
-```
-END
-}
-op {
-  graph_op_name: "SparseSlice"
-  endpoint {
-    name: "SparseSlice"
-  }
-  summary: "Slice a `SparseTensor` based on the `start` and `size`."
-  description: <<END
-For example, if the input is
-
-    input_tensor = shape = [2, 7]
-    [    a   d e  ]
-    [b c          ]
-
-Graphically the output tensors are:
-
-    sparse_slice([0, 0], [2, 4]) = shape = [2, 4]
-    [    a  ]
-    [b c    ]
-
-    sparse_slice([0, 4], [2, 3]) = shape = [2, 3]
-    [ d e  ]
-    [      ]
-END
-}
-op {
-  graph_op_name: "SparseSoftmax"
-  endpoint {
-    name: "SparseSoftmax"
-  }
-  summary: "Applies softmax to a batched N-D `SparseTensor`."
-  description: <<END
-The inputs represent an N-D SparseTensor  with logical shape `[..., B, C]`
-(where `N >= 2`), and with indices sorted in the canonical lexicographic order.
-
-This op is equivalent to applying the normal `tf.nn.softmax()` to each innermost
-logical submatrix with shape `[B, C]`, but with the catch that *the implicitly
-zero elements do not participate*.  Specifically, the algorithm is equivalent
-to the following:
-
-  (1) Applies `tf.nn.softmax()` to a densified view of each innermost submatrix
-      with shape `[B, C]`, along the size-C dimension;
-  (2) Masks out the original implicitly-zero locations;
-  (3) Renormalizes the remaining elements.
-
-Hence, the `SparseTensor` result has exactly the same non-zero indices and
-shape.
-END
-}
-op {
-  graph_op_name: "SparseSoftmaxCrossEntropyWithLogits"
-  endpoint {
-    name: "SparseSoftmaxCrossEntropyWithLogits"
-  }
-  summary: "Computes softmax cross entropy cost and gradients to backpropagate."
-  description: <<END
-Unlike `SoftmaxCrossEntropyWithLogits`, this operation does not accept
-a matrix of label probabilities, but rather a single label per row
-of features.  This label is considered to have probability 1.0 for the
-given row.
-
-Inputs are the logits, not probabilities.
-END
-}
-op {
-  graph_op_name: "SparseSparseMaximum"
-  endpoint {
-    name: "SparseSparseMaximum"
-  }
-  summary: "Returns the element-wise max of two SparseTensors."
-  description: <<END
-Assumes the two SparseTensors have the same shape, i.e., no broadcasting.
-END
-}
-op {
-  graph_op_name: "SparseSparseMinimum"
-  endpoint {
-    name: "SparseSparseMinimum"
-  }
-  summary: "Returns the element-wise min of two SparseTensors."
-  description: <<END
-Assumes the two SparseTensors have the same shape, i.e., no broadcasting.
-END
-}
-op {
-  graph_op_name: "SparseSplit"
-  endpoint {
-    name: "SparseSplit"
-  }
-  summary: "Split a `SparseTensor` into `num_split` tensors along one dimension."
-  description: <<END
-If the `shape[split_dim]` is not an integer multiple of `num_split`. Slices
-`[0 : shape[split_dim] % num_split]` gets one extra dimension.
-For example, if `split_dim = 1` and `num_split = 2` and the input is
-
-    input_tensor = shape = [2, 7]
-    [    a   d e  ]
-    [b c          ]
-
-Graphically the output tensors are:
-
-    output_tensor[0] = shape = [2, 4]
-    [    a  ]
-    [b c    ]
-
-    output_tensor[1] = shape = [2, 3]
-    [ d e  ]
-    [      ]
-END
-}
-op {
-  graph_op_name: "SparseTensorDenseAdd"
-  endpoint {
-    name: "SparseTensorDenseAdd"
-  }
-  summary: "Adds up a `SparseTensor` and a dense `Tensor`, producing a dense `Tensor`."
-  description: <<END
-This Op does not require `a_indices` be sorted in standard lexicographic order.
-END
-}
-op {
-  graph_op_name: "SparseTensorDenseMatMul"
-  endpoint {
-    name: "SparseTensorDenseMatMul"
-  }
-  summary: "Multiply SparseTensor (of rank 2) \"A\" by dense matrix \"B\"."
-  description: <<END
-No validity checking is performed on the indices of A.  However, the following
-input format is recommended for optimal behavior:
-
-if adjoint_a == false:
-  A should be sorted in lexicographically increasing order.  Use SparseReorder
-  if you're not sure.
-if adjoint_a == true:
-  A should be sorted in order of increasing dimension 1 (i.e., "column major"
-  order instead of "row major" order).
-END
-}
-op {
-  graph_op_name: "SparseTensorSliceDataset"
-  endpoint {
-    name: "SparseTensorSliceDataset"
-  }
-  summary: "Creates a dataset that splits a SparseTensor into elements row-wise."
-}
-op {
-  graph_op_name: "SparseToDense"
-  endpoint {
-    name: "SparseToDense"
-  }
-  summary: "Converts a sparse representation into a dense tensor."
-  description: <<END
-Builds an array `dense` with shape `output_shape` such that
-
-```
-# If sparse_indices is scalar
-dense[i] = (i == sparse_indices ? sparse_values : default_value)
-
-# If sparse_indices is a vector, then for each i
-dense[sparse_indices[i]] = sparse_values[i]
-
-# If sparse_indices is an n by d matrix, then for each i in [0, n)
-dense[sparse_indices[i][0], ..., sparse_indices[i][d-1]] = sparse_values[i]
-```
-
-All other values in `dense` are set to `default_value`.  If `sparse_values` is a
-scalar, all sparse indices are set to this single value.
-
-Indices should be sorted in lexicographic order, and indices must not
-contain any repeats. If `validate_indices` is true, these properties
-are checked during execution.
-END
-}
-op {
-  graph_op_name: "SparseToSparseSetOperation"
-  endpoint {
-    name: "SparseToSparseSetOperation"
-  }
-  summary: "Applies set operation along last dimension of 2 `SparseTensor` inputs."
-  description: <<END
-See SetOperationOp::SetOperationFromContext for values of `set_operation`.
-
-If `validate_indices` is `True`, `SparseToSparseSetOperation` validates the
-order and range of `set1` and `set2` indices.
-
-Input `set1` is a `SparseTensor` represented by `set1_indices`, `set1_values`,
-and `set1_shape`. For `set1` ranked `n`, 1st `n-1` dimensions must be the same
-as `set2`. Dimension `n` contains values in a set, duplicates are allowed but
-ignored.
-
-Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`,
-and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same
-as `set1`. Dimension `n` contains values in a set, duplicates are allowed but
-ignored.
-
-If `validate_indices` is `True`, this op validates the order and range of `set1`
-and `set2` indices.
-
-Output `result` is a `SparseTensor` represented by `result_indices`,
-`result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
-has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
-dimension contains the result of `set_operation` applied to the corresponding
-`[0...n-1]` dimension of `set`.
-END
-}
-op {
-  graph_op_name: "Split"
-  endpoint {
-    name: "Split"
-  }
-  summary: "Splits a tensor into `num_split` tensors along one dimension."
-}
-op {
-  graph_op_name: "SplitV"
-  endpoint {
-    name: "SplitV"
-  }
-  summary: "Splits a tensor into `num_split` tensors along one dimension."
-}
-op {
-  graph_op_name: "SqlDataset"
-  endpoint {
-    name: "SqlDataset"
-  }
-  summary: "Creates a dataset that executes a SQL query and emits rows of the result set."
-}
-op {
-  graph_op_name: "Sqrt"
-  endpoint {
-    name: "Sqrt"
-  }
-  summary: "Computes square root of x element-wise."
-  description: <<END
-I.e., \\(y = \sqrt{x} = x^{1/2}\\).
-END
-}
-op {
-  graph_op_name: "SqrtGrad"
-  endpoint {
-    name: "SqrtGrad"
-  }
-  summary: "Computes the gradient for the sqrt of `x` wrt its input."
-  description: <<END
-Specifically, `grad = dy * 0.5 / y`, where `y = sqrt(x)`, and `dy`
-is the corresponding input gradient.
-END
-}
-op {
-  graph_op_name: "Square"
-  endpoint {
-    name: "Square"
-  }
-  summary: "Computes square of x element-wise."
-  description: <<END
-I.e., \\(y = x * x = x^2\\).
-END
-}
-op {
-  graph_op_name: "SquaredDifference"
-  endpoint {
-    name: "SquaredDifference"
-  }
-  summary: "Returns (x - y)(x - y) element-wise."
-  description: <<END
-*NOTE*: `SquaredDifference` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "Squeeze"
-  endpoint {
-    name: "Squeeze"
-  }
-  summary: "Removes dimensions of size 1 from the shape of a tensor."
-  description: <<END
-Given a tensor `input`, this operation returns a tensor of the same type with
-all dimensions of size 1 removed. If you don't want to remove all size 1
-dimensions, you can remove specific size 1 dimensions by specifying
-`squeeze_dims`.
-
-For example:
-
-```
-# 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
-shape(squeeze(t)) ==> [2, 3]
-```
-
-Or, to remove specific size 1 dimensions:
-
-```
-# 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
-shape(squeeze(t, [2, 4])) ==> [1, 2, 3, 1]
-```
-END
-}
-op {
-  graph_op_name: "Stack"
-  endpoint {
-    name: "Stack"
-  }
-  summary: "Deprecated, use StackV2."
-}
-op {
-  graph_op_name: "StackClose"
-  endpoint {
-    name: "StackClose"
-  }
-  summary: "Deprecated, use StackCloseV2."
-}
-op {
-  graph_op_name: "StackCloseV2"
-  endpoint {
-    name: "StackCloseV2"
-  }
-  summary: "Delete the stack from its resource container."
-}
-op {
-  graph_op_name: "StackPop"
-  endpoint {
-    name: "StackPop"
-  }
-  summary: "Deprecated, use StackPopV2."
-}
-op {
-  graph_op_name: "StackPopV2"
-  endpoint {
-    name: "StackPopV2"
-  }
-  summary: "Pop the element at the top of the stack."
-}
-op {
-  graph_op_name: "StackPush"
-  endpoint {
-    name: "StackPush"
-  }
-  summary: "Deprecated, use StackPushV2."
-}
-op {
-  graph_op_name: "StackPushV2"
-  endpoint {
-    name: "StackPushV2"
-  }
-  summary: "Push an element onto the stack."
-}
-op {
-  graph_op_name: "StackV2"
-  endpoint {
-    name: "StackV2"
-  }
-  summary: "A stack that produces elements in first-in last-out order."
-}
-op {
-  graph_op_name: "Stage"
-  endpoint {
-    name: "Stage"
-  }
-  summary: "Stage values similar to a lightweight Enqueue."
-  description: <<END
-The basic functionality of this Op is similar to a queue with many
-fewer capabilities and options.  This Op is optimized for performance.
-END
-}
-op {
-  graph_op_name: "StageClear"
-  endpoint {
-    name: "StageClear"
-  }
-  summary: "Op removes all elements in the underlying container."
-}
-op {
-  graph_op_name: "StagePeek"
-  endpoint {
-    name: "StagePeek"
-  }
-  summary: "Op peeks at the values at the specified index.  If the"
-  description: <<END
-underlying container does not contain sufficient elements
-this op will block until it does.   This Op is optimized for
-performance.
-END
-}
-op {
-  graph_op_name: "StageSize"
-  endpoint {
-    name: "StageSize"
-  }
-  summary: "Op returns the number of elements in the underlying container."
-}
-op {
-  graph_op_name: "StatelessRandomNormal"
-  endpoint {
-    name: "StatelessRandomNormal"
-  }
-  summary: "Outputs deterministic pseudorandom values from a normal distribution."
-  description: <<END
-The generated values will have mean 0 and standard deviation 1.
-
-The outputs are a deterministic function of `shape` and `seed`.
-END
-}
-op {
-  graph_op_name: "StatelessRandomUniform"
-  endpoint {
-    name: "StatelessRandomUniform"
-  }
-  summary: "Outputs deterministic pseudorandom random values from a uniform distribution."
-  description: <<END
-The generated values follow a uniform distribution in the range `[0, 1)`. The
-lower bound 0 is included in the range, while the upper bound 1 is excluded.
-
-The outputs are a deterministic function of `shape` and `seed`.
-END
-}
-op {
-  graph_op_name: "StatelessTruncatedNormal"
-  endpoint {
-    name: "StatelessTruncatedNormal"
-  }
-  summary: "Outputs deterministic pseudorandom values from a truncated normal distribution."
-  description: <<END
-The generated values follow a normal distribution with mean 0 and standard
-deviation 1, except that values whose magnitude is more than 2 standard
-deviations from the mean are dropped and re-picked.
-
-The outputs are a deterministic function of `shape` and `seed`.
-END
-}
-op {
-  graph_op_name: "StopGradient"
-  endpoint {
-    name: "StopGradient"
-  }
-  summary: "Stops gradient computation."
-  description: <<END
-When executed in a graph, this op outputs its input tensor as-is.
-
-When building ops to compute gradients, this op prevents the contribution of
-its inputs to be taken into account.  Normally, the gradient generator adds ops
-to a graph to compute the derivatives of a specified 'loss' by recursively
-finding out inputs that contributed to its computation.  If you insert this op
-in the graph it inputs are masked from the gradient generator.  They are not
-taken into account for computing gradients.
-
-This is useful any time you want to compute a value with TensorFlow but need
-to pretend that the value was a constant. Some examples include:
-
-*  The *EM* algorithm where the *M-step* should not involve backpropagation
-   through the output of the *E-step*.
-*  Contrastive divergence training of Boltzmann machines where, when
-   differentiating the energy function, the training must not backpropagate
-   through the graph that generated the samples from the model.
-*  Adversarial training, where no backprop should happen through the adversarial
-   example generation process.
-END
-}
-op {
-  graph_op_name: "StridedSlice"
-  endpoint {
-    name: "StridedSlice"
-  }
-  summary: "Return a strided slice from `input`."
-  description: <<END
-Note, most python users will want to use the Python `Tensor.__getitem__`
-or `Variable.__getitem__` rather than this op directly.
-
-The goal of this op is to produce a new tensor with a subset of
-the elements from the `n` dimensional `input` tensor. The subset is chosen using
-a sequence of `m` sparse range specifications encoded into the arguments
-of this function. Note, in some cases
-`m` could be equal to `n`, but this need not be the case. Each
-range specification entry can be one of the following:
-
-- An ellipsis (...). Ellipses are used to imply zero or more
-  dimensions of full-dimension selection and are produced using
-  `ellipsis_mask`. For example, `foo[...]` is the identity slice.
-
-- A new axis. This is used to insert a new shape=1 dimension and is
-  produced using `new_axis_mask`. For example, `foo[:, ...]` where
-  `foo` is shape `(3, 4)` produces a `(1, 3, 4)` tensor.
-
-
-- A range `begin:end:stride`. This is used to specify how much to choose from
-  a given dimension. `stride` can be any integer but 0.  `begin` is an integer
-  which represents the index of the first value to select while `end` represents
-  the index of the last value to select. The number of values selected in each
-  dimension is `end - begin` if `stride > 0` and `begin - end` if `stride < 0`.
-  `begin` and `end` can be negative where `-1` is the last element, `-2` is
-  the second to last. `begin_mask` controls whether to replace the explicitly
-  given `begin` with an implicit effective value of `0` if `stride > 0` and
-  `-1` if `stride < 0`. `end_mask` is analogous but produces the number
-  required to create the largest open interval. For example, given a shape
-  `(3,)` tensor `foo[:]`, the effective `begin` and `end` are `0` and `3`. Do
-  not assume this is equivalent to `foo[0:-1]` which has an effective `begin`
-  and `end` of `0` and `2`. Another example is `foo[-2::-1]` which reverses the
-  first dimension of a tensor while dropping the last two (in the original
-  order elements). For example `foo = [1,2,3,4]; foo[-2::-1]` is `[4,3]`.
-
-- A single index. This is used to keep only elements that have a given
-  index. For example (`foo[2, :]` on a shape `(5,6)` tensor produces a
-  shape `(6,)` tensor. This is encoded in `begin` and `end` and
-  `shrink_axis_mask`.
-
-Each conceptual range specification is encoded in the op's argument. This
-encoding is best understand by considering a non-trivial example. In
-particular,
-`foo[1, 2:4, None, ..., :-3:-1, :]` will be encoded as
-
-```
-begin = [1, 2, x, x, 0, x] # x denotes don't care (usually 0)
-end = [2, 4, x, x, -3, x]
-strides = [1, 1, x, x, -1, 1]
-begin_mask = 1<<4 | 1 << 5 = 48
-end_mask = 1<<5 = 32
-ellipsis_mask = 1<<3 = 8
-new_axis_mask = 1<<2 4
-shrink_axis_mask = 1<<0
-```
-
-In this case if `foo.shape` is (5, 5, 5, 5, 5, 5) the final shape of
-the slice becomes (2, 1, 5, 5, 2, 5).
-Let us walk step by step through each argument specification.
-
-1.  The first argument in the example slice is turned into `begin = 1` and
-`end = begin + 1 = 2`. To disambiguate from the original spec `2:4` we
-also set the appropriate bit in `shrink_axis_mask`.
-
-2. `2:4` is contributes 2, 4, 1 to begin, end, and stride. All masks have
-zero bits contributed.
-
-3. None is a synonym for `tf.newaxis`. This means insert a dimension of size 1
-dimension in the final shape. Dummy values are contributed to begin,
-end and stride, while the new_axis_mask bit is set.
-
-4. `...` grab the full ranges from as many dimensions as needed to
-fully specify a slice for every dimension of the input shape.
-
-5. `:-3:-1` shows the use of negative indices. A negative index `i` associated
-with a dimension that has shape `s` is converted to a positive index
-`s + i`. So `-1` becomes `s-1` (i.e. the last element). This conversion
-is done internally so begin, end and strides receive x, -3, and -1.
-The appropriate begin_mask bit is set to indicate the start range is the
-full range (ignoring the x).
-
-6. `:` indicates that the entire contents of the corresponding dimension
-is selected. This is equivalent to `::` or `0::1`. begin, end, and strides
-receive 0, 0, and 1, respectively. The appropriate bits in `begin_mask` and
-`end_mask` are also set.
-
-*Requirements*:
-  `0 != strides[i] for i in [0, m)`
-  `ellipsis_mask must be a power of two (only one ellipsis)`
-END
-}
-op {
-  graph_op_name: "StridedSliceAssign"
-  endpoint {
-    name: "StridedSliceAssign"
-  }
-  summary: "Assign `value` to the sliced l-value reference of `ref`."
-  description: <<END
-The values of `value` are assigned to the positions in the variable
-`ref` that are selected by the slice parameters. The slice parameters
-`begin, `end`, `strides`, etc. work exactly as in `StridedSlice`.
-
-NOTE this op currently does not support broadcasting and so `value`'s
-shape must be exactly the shape produced by the slice of `ref`.
-END
-}
-op {
-  graph_op_name: "StridedSliceGrad"
-  endpoint {
-    name: "StridedSliceGrad"
-  }
-  summary: "Returns the gradient of `StridedSlice`."
-  description: <<END
-Since `StridedSlice` cuts out pieces of its `input` which is size
-`shape`, its gradient will have the same shape (which is passed here
-as `shape`). The gradient will be zero in any element that the slice
-does not select.
-
-Arguments are the same as StridedSliceGrad with the exception that
-`dy` is the input gradient to be propagated and `shape` is the
-shape of `StridedSlice`'s `input`.
-END
-}
-op {
-  graph_op_name: "StringJoin"
-  endpoint {
-    name: "StringJoin"
-  }
-  summary: "Joins the strings in the given list of string tensors into one tensor;"
-  description: <<END
-with the given separator (default is an empty separator).
-END
-}
-op {
-  graph_op_name: "StringSplit"
-  endpoint {
-    name: "StringSplit"
-  }
-  summary: "Split elements of `input` based on `delimiter` into a `SparseTensor`."
-  description: <<END
-Let N be the size of source (typically N will be the batch size). Split each
-element of `input` based on `delimiter` and return a `SparseTensor`
-containing the splitted tokens. Empty tokens are ignored.
-
-`delimiter` can be empty, or a string of split characters. If `delimiter` is an
- empty string, each element of `input` is split into individual single-byte
- character strings, including splitting of UTF-8 multibyte sequences. Otherwise
- every character of `delimiter` is a potential split point.
-
-For example:
-  N = 2, input[0] is 'hello world' and input[1] is 'a b c', then the output
-  will be
-
-  indices = [0, 0;
-             0, 1;
-             1, 0;
-             1, 1;
-             1, 2]
-  shape = [2, 3]
-  values = ['hello', 'world', 'a', 'b', 'c']
-END
-}
-op {
-  graph_op_name: "StringToHashBucket"
-  endpoint {
-    name: "StringToHashBucket"
-  }
-  summary: "Converts each string in the input Tensor to its hash mod by a number of buckets."
-  description: <<END
-The hash function is deterministic on the content of the string within the
-process.
-
-Note that the hash function may change from time to time.
-This functionality will be deprecated and it's recommended to use
-`tf.string_to_hash_bucket_fast()` or `tf.string_to_hash_bucket_strong()`.
-END
-}
-op {
-  graph_op_name: "StringToHashBucketFast"
-  endpoint {
-    name: "StringToHashBucketFast"
-  }
-  summary: "Converts each string in the input Tensor to its hash mod by a number of buckets."
-  description: <<END
-The hash function is deterministic on the content of the string within the
-process and will never change. However, it is not suitable for cryptography.
-This function may be used when CPU time is scarce and inputs are trusted or
-unimportant. There is a risk of adversaries constructing inputs that all hash
-to the same bucket. To prevent this problem, use a strong hash function with
-`tf.string_to_hash_bucket_strong`.
-END
-}
-op {
-  graph_op_name: "StringToHashBucketStrong"
-  endpoint {
-    name: "StringToHashBucketStrong"
-  }
-  summary: "Converts each string in the input Tensor to its hash mod by a number of buckets."
-  description: <<END
-The hash function is deterministic on the content of the string within the
-process. The hash function is a keyed hash function, where attribute `key`
-defines the key of the hash function. `key` is an array of 2 elements.
-
-A strong hash is important when inputs may be malicious, e.g. URLs with
-additional components. Adversaries could try to make their inputs hash to the
-same bucket for a denial-of-service attack or to skew the results. A strong
-hash prevents this by making it difficult, if not infeasible, to compute inputs
-that hash to the same bucket. This comes at a cost of roughly 4x higher compute
-time than `tf.string_to_hash_bucket_fast`.
-END
-}
-op {
-  graph_op_name: "StringToNumber"
-  endpoint {
-    name: "StringToNumber"
-  }
-  summary: "Converts each string in the input Tensor to the specified numeric type."
-  description: <<END
-(Note that int32 overflow results in an error while float overflow
-results in a rounded value.)
-END
-}
-op {
-  graph_op_name: "Sub"
-  endpoint {
-    name: "Sub"
-  }
-  summary: "Returns x - y element-wise."
-  description: <<END
-*NOTE*: `Sub` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "Substr"
-  endpoint {
-    name: "Substr"
-  }
-  summary: "Return substrings from `Tensor` of strings."
-  description: <<END
-For each string in the input `Tensor`, creates a substring starting at index
-`pos` with a total length of `len`.
-
-If `len` defines a substring that would extend beyond the length of the input
-string, then as many characters as possible are used.
-
-If `pos` is negative or specifies a character index larger than any of the input
-strings, then an `InvalidArgumentError` is thrown.
-
-`pos` and `len` must have the same shape, otherwise a `ValueError` is thrown on
-Op creation.
-
-*NOTE*: `Substr` supports broadcasting up to two dimensions. More about
-broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-
----
-
-Examples
-
-Using scalar `pos` and `len`:
-
-```python
-input = [b'Hello', b'World']
-position = 1
-length = 3
-
-output = [b'ell', b'orl']
-```
-
-Using `pos` and `len` with same shape as `input`:
-
-```python
-input = [[b'ten', b'eleven', b'twelve'],
-         [b'thirteen', b'fourteen', b'fifteen'],
-         [b'sixteen', b'seventeen', b'eighteen']]
-position = [[1, 2, 3],
-            [1, 2, 3],
-            [1, 2, 3]]
-length =   [[2, 3, 4],
-            [4, 3, 2],
-            [5, 5, 5]]
-
-output = [[b'en', b'eve', b'lve'],
-          [b'hirt', b'urt', b'te'],
-          [b'ixtee', b'vente', b'hteen']]
-```
-
-Broadcasting `pos` and `len` onto `input`:
-
-```
-input = [[b'ten', b'eleven', b'twelve'],
-         [b'thirteen', b'fourteen', b'fifteen'],
-         [b'sixteen', b'seventeen', b'eighteen'],
-         [b'nineteen', b'twenty', b'twentyone']]
-position = [1, 2, 3]
-length =   [1, 2, 3]
-
-output = [[b'e', b'ev', b'lve'],
-          [b'h', b'ur', b'tee'],
-          [b'i', b've', b'hte'],
-          [b'i', b'en', b'nty']]
-```
-
-Broadcasting `input` onto `pos` and `len`:
-
-```
-input = b'thirteen'
-position = [1, 5, 7]
-length =   [3, 2, 1]
-
-output = [b'hir', b'ee', b'n']
-```
-END
-}
-op {
-  graph_op_name: "Sum"
-  endpoint {
-    name: "Sum"
-  }
-  summary: "Computes the sum of elements across dimensions of a tensor."
-  description: <<END
-Reduces `input` along the dimensions given in `reduction_indices`. Unless
-`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-`reduction_indices`. If `keep_dims` is true, the reduced dimensions are
-retained with length 1.
-END
-}
-op {
-  graph_op_name: "Svd"
-  endpoint {
-    name: "Svd"
-  }
-  summary: "Computes the singular value decompositions of one or more matrices."
-  description: <<END
-Computes the SVD of each inner matrix in `input` such that
-`input[..., :, :] = u[..., :, :] * diag(s[..., :, :]) * transpose(v[..., :, :])`
-
-```python
-# a is a tensor containing a batch of matrices.
-# s is a tensor of singular values for each matrix.
-# u is the tensor containing of left singular vectors for each matrix.
-# v is the tensor containing of right singular vectors for each matrix.
-s, u, v = svd(a)
-s, _, _ = svd(a, compute_uv=False)
-```
-END
-}
-op {
-  graph_op_name: "Switch"
-  endpoint {
-    name: "Switch"
-  }
-  summary: "Forwards `data` to the output port determined by `pred`."
-  description: <<END
-If `pred` is true, the `data` input is forwarded to `output_true`. Otherwise,
-the data goes to `output_false`.
-
-See also `RefSwitch` and `Merge`.
-END
-}
-op {
-  graph_op_name: "SymbolicGradient"
-  endpoint {
-    name: "SymbolicGradient"
-  }
-  summary: "Computes the gradient function for function f via backpropagation."
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_SampleDistortedBoundingBox.pbtxt b/tensorflow/core/api_def/base_api/api_def_SampleDistortedBoundingBox.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0716b2611403b54d894007fad801380f30e70acc
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SampleDistortedBoundingBox.pbtxt
@@ -0,0 +1,131 @@
+op {
+  graph_op_name: "SampleDistortedBoundingBox"
+  in_arg {
+    name: "image_size"
+    description: <<END
+1-D, containing `[height, width, channels]`.
+END
+  }
+  in_arg {
+    name: "bounding_boxes"
+    description: <<END
+3-D with shape `[batch, N, 4]` describing the N bounding boxes
+associated with the image.
+END
+  }
+  out_arg {
+    name: "begin"
+    description: <<END
+1-D, containing `[offset_height, offset_width, 0]`. Provide as input to
+`tf.slice`.
+END
+  }
+  out_arg {
+    name: "size"
+    description: <<END
+1-D, containing `[target_height, target_width, -1]`. Provide as input to
+`tf.slice`.
+END
+  }
+  out_arg {
+    name: "bboxes"
+    description: <<END
+3-D with shape `[1, 1, 4]` containing the distorted bounding box.
+Provide as input to `tf.image.draw_bounding_boxes`.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either `seed` or `seed2` are set to non-zero, the random number
+generator is seeded by the given `seed`.  Otherwise, it is seeded by a random
+seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+A second seed to avoid seed collision.
+END
+  }
+  attr {
+    name: "min_object_covered"
+    description: <<END
+The cropped area of the image must contain at least this
+fraction of any bounding box supplied. The value of this parameter should be
+non-negative. In the case of 0, the cropped area does not need to overlap
+any of the bounding boxes supplied.
+END
+  }
+  attr {
+    name: "aspect_ratio_range"
+    description: <<END
+The cropped area of the image must have an aspect ratio =
+width / height within this range.
+END
+  }
+  attr {
+    name: "area_range"
+    description: <<END
+The cropped area of the image must contain a fraction of the
+supplied image within in this range.
+END
+  }
+  attr {
+    name: "max_attempts"
+    description: <<END
+Number of attempts at generating a cropped region of the image
+of the specified constraints. After `max_attempts` failures, return the entire
+image.
+END
+  }
+  attr {
+    name: "use_image_if_no_bounding_boxes"
+    description: <<END
+Controls behavior if no bounding boxes supplied.
+If true, assume an implicit bounding box covering the whole input. If false,
+raise an error.
+END
+  }
+  summary: "Generate a single randomly distorted bounding box for an image."
+  description: <<END
+Bounding box annotations are often supplied in addition to ground-truth labels
+in image recognition or object localization tasks. A common technique for
+training such a system is to randomly distort an image while preserving
+its content, i.e. *data augmentation*. This Op outputs a randomly distorted
+localization of an object, i.e. bounding box, given an `image_size`,
+`bounding_boxes` and a series of constraints.
+
+The output of this Op is a single bounding box that may be used to crop the
+original image. The output is returned as 3 tensors: `begin`, `size` and
+`bboxes`. The first 2 tensors can be fed directly into `tf.slice` to crop the
+image. The latter may be supplied to `tf.image.draw_bounding_boxes` to visualize
+what the bounding box looks like.
+
+Bounding boxes are supplied and returned as `[y_min, x_min, y_max, x_max]`. The
+bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
+height of the underlying image.
+
+For example,
+
+```python
+    # Generate a single distorted bounding box.
+    begin, size, bbox_for_draw = tf.image.sample_distorted_bounding_box(
+        tf.shape(image),
+        bounding_boxes=bounding_boxes)
+
+    # Draw the bounding box in an image summary.
+    image_with_box = tf.image.draw_bounding_boxes(tf.expand_dims(image, 0),
+                                                  bbox_for_draw)
+    tf.image_summary('images_with_box', image_with_box)
+
+    # Employ the bounding box to distort the image.
+    distorted_image = tf.slice(image, begin, size)
+```
+
+Note that if no bounding box information is available, setting
+`use_image_if_no_bounding_boxes = true` will assume there is a single implicit
+bounding box covering the whole image. If `use_image_if_no_bounding_boxes` is
+false and no bounding boxes are supplied, an error is raised.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SampleDistortedBoundingBoxV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_SampleDistortedBoundingBoxV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e9912609729fbadf7a3dd706903ecc4d915d72eb
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SampleDistortedBoundingBoxV2.pbtxt
@@ -0,0 +1,131 @@
+op {
+  graph_op_name: "SampleDistortedBoundingBoxV2"
+  in_arg {
+    name: "image_size"
+    description: <<END
+1-D, containing `[height, width, channels]`.
+END
+  }
+  in_arg {
+    name: "bounding_boxes"
+    description: <<END
+3-D with shape `[batch, N, 4]` describing the N bounding boxes
+associated with the image.
+END
+  }
+  in_arg {
+    name: "min_object_covered"
+    description: <<END
+The cropped area of the image must contain at least this
+fraction of any bounding box supplied. The value of this parameter should be
+non-negative. In the case of 0, the cropped area does not need to overlap
+any of the bounding boxes supplied.
+END
+  }
+  out_arg {
+    name: "begin"
+    description: <<END
+1-D, containing `[offset_height, offset_width, 0]`. Provide as input to
+`tf.slice`.
+END
+  }
+  out_arg {
+    name: "size"
+    description: <<END
+1-D, containing `[target_height, target_width, -1]`. Provide as input to
+`tf.slice`.
+END
+  }
+  out_arg {
+    name: "bboxes"
+    description: <<END
+3-D with shape `[1, 1, 4]` containing the distorted bounding box.
+Provide as input to `tf.image.draw_bounding_boxes`.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either `seed` or `seed2` are set to non-zero, the random number
+generator is seeded by the given `seed`.  Otherwise, it is seeded by a random
+seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+A second seed to avoid seed collision.
+END
+  }
+  attr {
+    name: "aspect_ratio_range"
+    description: <<END
+The cropped area of the image must have an aspect ratio =
+width / height within this range.
+END
+  }
+  attr {
+    name: "area_range"
+    description: <<END
+The cropped area of the image must contain a fraction of the
+supplied image within in this range.
+END
+  }
+  attr {
+    name: "max_attempts"
+    description: <<END
+Number of attempts at generating a cropped region of the image
+of the specified constraints. After `max_attempts` failures, return the entire
+image.
+END
+  }
+  attr {
+    name: "use_image_if_no_bounding_boxes"
+    description: <<END
+Controls behavior if no bounding boxes supplied.
+If true, assume an implicit bounding box covering the whole input. If false,
+raise an error.
+END
+  }
+  summary: "Generate a single randomly distorted bounding box for an image."
+  description: <<END
+Bounding box annotations are often supplied in addition to ground-truth labels
+in image recognition or object localization tasks. A common technique for
+training such a system is to randomly distort an image while preserving
+its content, i.e. *data augmentation*. This Op outputs a randomly distorted
+localization of an object, i.e. bounding box, given an `image_size`,
+`bounding_boxes` and a series of constraints.
+
+The output of this Op is a single bounding box that may be used to crop the
+original image. The output is returned as 3 tensors: `begin`, `size` and
+`bboxes`. The first 2 tensors can be fed directly into `tf.slice` to crop the
+image. The latter may be supplied to `tf.image.draw_bounding_boxes` to visualize
+what the bounding box looks like.
+
+Bounding boxes are supplied and returned as `[y_min, x_min, y_max, x_max]`. The
+bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
+height of the underlying image.
+
+For example,
+
+```python
+    # Generate a single distorted bounding box.
+    begin, size, bbox_for_draw = tf.image.sample_distorted_bounding_box(
+        tf.shape(image),
+        bounding_boxes=bounding_boxes)
+
+    # Draw the bounding box in an image summary.
+    image_with_box = tf.image.draw_bounding_boxes(tf.expand_dims(image, 0),
+                                                  bbox_for_draw)
+    tf.image_summary('images_with_box', image_with_box)
+
+    # Employ the bounding box to distort the image.
+    distorted_image = tf.slice(image, begin, size)
+```
+
+Note that if no bounding box information is available, setting
+`use_image_if_no_bounding_boxes = true` will assume there is a single implicit
+bounding box covering the whole image. If `use_image_if_no_bounding_boxes` is
+false and no bounding boxes are supplied, an error is raised.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Save.pbtxt b/tensorflow/core/api_def/base_api/api_def_Save.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ee75d6e4a6a9c2a1fa2ed17d2e9c163875c055db
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Save.pbtxt
@@ -0,0 +1,29 @@
+op {
+  graph_op_name: "Save"
+  in_arg {
+    name: "filename"
+    description: <<END
+Must have a single element. The name of the file to which we write
+the tensor.
+END
+  }
+  in_arg {
+    name: "tensor_names"
+    description: <<END
+Shape `[N]`. The names of the tensors to be saved.
+END
+  }
+  in_arg {
+    name: "data"
+    description: <<END
+`N` tensors to save.
+END
+  }
+  summary: "Saves the input tensors to disk."
+  description: <<END
+The size of `tensor_names` must match the number of tensors in `data`. `data[i]`
+is written to `filename` with name `tensor_names[i]`.
+
+See also `SaveSlices`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SaveSlices.pbtxt b/tensorflow/core/api_def/base_api/api_def_SaveSlices.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..61df999b2d0bf572a5231a8371df533ef5327147
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SaveSlices.pbtxt
@@ -0,0 +1,53 @@
+op {
+  graph_op_name: "SaveSlices"
+  in_arg {
+    name: "filename"
+    description: <<END
+Must have a single element. The name of the file to which we write the
+tensor.
+END
+  }
+  in_arg {
+    name: "tensor_names"
+    description: <<END
+Shape `[N]`. The names of the tensors to be saved.
+END
+  }
+  in_arg {
+    name: "shapes_and_slices"
+    description: <<END
+Shape `[N]`.  The shapes and slice specifications to use when
+saving the tensors.
+END
+  }
+  in_arg {
+    name: "data"
+    description: <<END
+`N` tensors to save.
+END
+  }
+  summary: "Saves input tensors slices to disk."
+  description: <<END
+This is like `Save` except that tensors can be listed in the saved file as being
+a slice of a larger tensor.  `shapes_and_slices` specifies the shape of the
+larger tensor and the slice that this tensor covers. `shapes_and_slices` must
+have as many elements as `tensor_names`.
+
+Elements of the `shapes_and_slices` input must either be:
+
+*  The empty string, in which case the corresponding tensor is
+   saved normally.
+*  A string of the form `dim0 dim1 ... dimN-1 slice-spec` where the
+   `dimI` are the dimensions of the larger tensor and `slice-spec`
+   specifies what part is covered by the tensor to save.
+
+`slice-spec` itself is a `:`-separated list: `slice0:slice1:...:sliceN-1`
+where each `sliceI` is either:
+
+*  The string `-` meaning that the slice covers all indices of this dimension
+*  `start,length` where `start` and `length` are integers.  In that
+   case the slice covers `length` indices starting at `start`.
+
+See also `Save`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SaveV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_SaveV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ee87514f25ffbcc98e797d1461f69764c266a6dd
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SaveV2.pbtxt
@@ -0,0 +1,35 @@
+op {
+  graph_op_name: "SaveV2"
+  in_arg {
+    name: "prefix"
+    description: <<END
+Must have a single element. The prefix of the V2 checkpoint to which we
+write the tensors.
+END
+  }
+  in_arg {
+    name: "tensor_names"
+    description: <<END
+shape {N}. The names of the tensors to be saved.
+END
+  }
+  in_arg {
+    name: "shape_and_slices"
+    description: <<END
+shape {N}.  The slice specs of the tensors to be saved.
+Empty strings indicate that they are non-partitioned tensors.
+END
+  }
+  in_arg {
+    name: "tensors"
+    description: <<END
+`N` tensors to save.
+END
+  }
+  summary: "Saves tensors in V2 checkpoint format."
+  description: <<END
+By default, saves the named tensors in full.  If the caller wishes to save
+specific slices of full tensors, "shape_and_slices" should be non-empty strings
+and correspondingly well-formed.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ScalarSummary.pbtxt b/tensorflow/core/api_def/base_api/api_def_ScalarSummary.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2cedb05b719904d960e767df9fae12b019f4230e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ScalarSummary.pbtxt
@@ -0,0 +1,26 @@
+op {
+  graph_op_name: "ScalarSummary"
+  in_arg {
+    name: "tags"
+    description: <<END
+Tags for the summary.
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+Same shape as `tags.  Values for the summary.
+END
+  }
+  out_arg {
+    name: "summary"
+    description: <<END
+Scalar.  Serialized `Summary` protocol buffer.
+END
+  }
+  summary: "Outputs a `Summary` protocol buffer with scalar values."
+  description: <<END
+The input `tags` and `values` must have the same shape.  The generated summary
+has a summary value for each tag-value pair in `tags` and `values`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ScanDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_ScanDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e83d4a9e967f959b19adc5fad38a7141f8936cc4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ScanDataset.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ScanDataset"
+  summary: "Creates a dataset successively reduces `f` over the elements of `input_dataset`."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ScatterAdd.pbtxt b/tensorflow/core/api_def/base_api/api_def_ScatterAdd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4b5201f025b438a1e6bba41035004b82ab876de7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ScatterAdd.pbtxt
@@ -0,0 +1,60 @@
+op {
+  graph_op_name: "ScatterAdd"
+  in_arg {
+    name: "ref"
+    description: <<END
+Should be from a `Variable` node.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A tensor of indices into the first dimension of `ref`.
+END
+  }
+  in_arg {
+    name: "updates"
+    description: <<END
+A tensor of updated values to add to `ref`.
+END
+  }
+  out_arg {
+    name: "output_ref"
+    description: <<END
+= Same as `ref`.  Returned as a convenience for operations that want
+to use the updated values after the update is done.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, the addition will be protected by a lock;
+otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Adds sparse updates to a variable reference."
+  description: <<END
+This operation computes
+
+    # Scalar indices
+    ref[indices, ...] += updates[...]
+
+    # Vector indices (for each i)
+    ref[indices[i], ...] += updates[i, ...]
+
+    # High rank indices (for each i, ..., j)
+    ref[indices[i, ..., j], ...] += updates[i, ..., j, ...]
+
+This operation outputs `ref` after the update is done.
+This makes it easier to chain operations that need to use the reset value.
+
+Duplicate entries are handled correctly: if multiple `indices` reference
+the same location, their contributions add.
+
+Requires `updates.shape = indices.shape + ref.shape[1:]`.
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src="https://www.tensorflow.org/images/ScatterAdd.png" alt>
+</div>
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ScatterDiv.pbtxt b/tensorflow/core/api_def/base_api/api_def_ScatterDiv.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..771cf0b591367e18f007e91bf66bc1cfd02ab459
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ScatterDiv.pbtxt
@@ -0,0 +1,58 @@
+op {
+  graph_op_name: "ScatterDiv"
+  in_arg {
+    name: "ref"
+    description: <<END
+Should be from a `Variable` node.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A tensor of indices into the first dimension of `ref`.
+END
+  }
+  in_arg {
+    name: "updates"
+    description: <<END
+A tensor of values that `ref` is divided by.
+END
+  }
+  out_arg {
+    name: "output_ref"
+    description: <<END
+= Same as `ref`.  Returned as a convenience for operations that want
+to use the updated values after the update is done.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, the operation will be protected by a lock;
+otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Divides a variable reference by sparse updates."
+  description: <<END
+This operation computes
+
+```python
+    # Scalar indices
+    ref[indices, ...] /= updates[...]
+
+    # Vector indices (for each i)
+    ref[indices[i], ...] /= updates[i, ...]
+
+    # High rank indices (for each i, ..., j)
+    ref[indices[i, ..., j], ...] /= updates[i, ..., j, ...]
+```
+
+This operation outputs `ref` after the update is done.
+This makes it easier to chain operations that need to use the reset value.
+
+Duplicate entries are handled correctly: if multiple `indices` reference
+the same location, their contributions divide.
+
+Requires `updates.shape = indices.shape + ref.shape[1:]`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ScatterMul.pbtxt b/tensorflow/core/api_def/base_api/api_def_ScatterMul.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a51f571b00d7fc68a24dbfc4a0104522f8c0f559
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ScatterMul.pbtxt
@@ -0,0 +1,58 @@
+op {
+  graph_op_name: "ScatterMul"
+  in_arg {
+    name: "ref"
+    description: <<END
+Should be from a `Variable` node.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A tensor of indices into the first dimension of `ref`.
+END
+  }
+  in_arg {
+    name: "updates"
+    description: <<END
+A tensor of updated values to multiply to `ref`.
+END
+  }
+  out_arg {
+    name: "output_ref"
+    description: <<END
+= Same as `ref`.  Returned as a convenience for operations that want
+to use the updated values after the update is done.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, the operation will be protected by a lock;
+otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Multiplies sparse updates into a variable reference."
+  description: <<END
+This operation computes
+
+```python
+    # Scalar indices
+    ref[indices, ...] *= updates[...]
+
+    # Vector indices (for each i)
+    ref[indices[i], ...] *= updates[i, ...]
+
+    # High rank indices (for each i, ..., j)
+    ref[indices[i, ..., j], ...] *= updates[i, ..., j, ...]
+```
+
+This operation outputs `ref` after the update is done.
+This makes it easier to chain operations that need to use the reset value.
+
+Duplicate entries are handled correctly: if multiple `indices` reference
+the same location, their contributions multiply.
+
+Requires `updates.shape = indices.shape + ref.shape[1:]`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ScatterNd.pbtxt b/tensorflow/core/api_def/base_api/api_def_ScatterNd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..23732546edaf120eb1a1a9b45219014ba55c6d81
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ScatterNd.pbtxt
@@ -0,0 +1,102 @@
+op {
+  graph_op_name: "ScatterNd"
+  in_arg {
+    name: "indices"
+    description: <<END
+Index tensor.
+END
+  }
+  in_arg {
+    name: "updates"
+    description: <<END
+Updates to scatter into output.
+END
+  }
+  in_arg {
+    name: "shape"
+    description: <<END
+1-D. The shape of the resulting tensor.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A new tensor with the given shape and updates applied according
+to the indices.
+END
+  }
+  summary: "Scatter `updates` into a new (initially zero) tensor according to `indices`."
+  description: <<END
+Creates a new tensor by applying sparse `updates` to individual
+values or slices within a zero tensor of the given `shape` according to
+indices.  This operator is the inverse of the @{tf.gather_nd} operator which
+extracts values or slices from a given tensor.
+
+**WARNING**: The order in which updates are applied is nondeterministic, so the
+output will be nondeterministic if `indices` contains duplicates.
+
+`indices` is an integer tensor containing indices into a new tensor of shape
+`shape`.  The last dimension of `indices` can be at most the rank of `shape`:
+
+    indices.shape[-1] <= shape.rank
+
+The last dimension of `indices` corresponds to indices into elements
+(if `indices.shape[-1] = shape.rank`) or slices
+(if `indices.shape[-1] < shape.rank`) along dimension `indices.shape[-1]` of
+`shape`.  `updates` is a tensor with shape
+
+    indices.shape[:-1] + shape[indices.shape[-1]:]
+
+The simplest form of scatter is to insert individual elements in a tensor by
+index. For example, say we want to insert 4 scattered elements in a rank-1
+tensor with 8 elements.
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src="https://www.tensorflow.org/images/ScatterNd1.png" alt>
+</div>
+
+In Python, this scatter operation would look like this:
+
+```python
+    indices = tf.constant([[4], [3], [1], [7]])
+    updates = tf.constant([9, 10, 11, 12])
+    shape = tf.constant([8])
+    scatter = tf.scatter_nd(indices, updates, shape)
+    with tf.Session() as sess:
+      print(sess.run(scatter))
+```
+
+The resulting tensor would look like this:
+
+    [0, 11, 0, 10, 9, 0, 0, 12]
+
+We can also, insert entire slices of a higher rank tensor all at once. For
+example, if we wanted to insert two slices in the first dimension of a
+rank-3 tensor with two matrices of new values.
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src="https://www.tensorflow.org/images/ScatterNd2.png" alt>
+</div>
+
+In Python, this scatter operation would look like this:
+
+```python
+    indices = tf.constant([[0], [2]])
+    updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
+                            [7, 7, 7, 7], [8, 8, 8, 8]],
+                           [[5, 5, 5, 5], [6, 6, 6, 6],
+                            [7, 7, 7, 7], [8, 8, 8, 8]]])
+    shape = tf.constant([4, 4, 4])
+    scatter = tf.scatter_nd(indices, updates, shape)
+    with tf.Session() as sess:
+      print(sess.run(scatter))
+```
+
+The resulting tensor would look like this:
+
+    [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+     [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]],
+     [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+     [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]]
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ScatterNdAdd.pbtxt b/tensorflow/core/api_def/base_api/api_def_ScatterNdAdd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b0665ebf0e0ff6f8be34fb134e1b0d1adfa74eba
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ScatterNdAdd.pbtxt
@@ -0,0 +1,74 @@
+op {
+  graph_op_name: "ScatterNdAdd"
+  in_arg {
+    name: "ref"
+    description: <<END
+A mutable Tensor. Should be from a Variable node.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A Tensor. Must be one of the following types: int32, int64.
+A tensor of indices into ref.
+END
+  }
+  in_arg {
+    name: "updates"
+    description: <<END
+A Tensor. Must have the same type as ref. A tensor of updated values
+to add to ref.
+END
+  }
+  out_arg {
+    name: "output_ref"
+    description: <<END
+Same as ref. Returned as a convenience for operations that want
+to use the updated values after the update is done.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+An optional bool. Defaults to True. If True, the assignment will
+be protected by a lock; otherwise the behavior is undefined,
+but may exhibit less contention.
+END
+  }
+  summary: "Applies sparse addition between `updates` and individual values or slices"
+  description: <<END
+within a given variable according to `indices`.
+
+`ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
+
+`indices` must be integer tensor, containing indices into `ref`.
+It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
+
+The innermost dimension of `indices` (with length `K`) corresponds to
+indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
+dimension of `ref`.
+
+`updates` is `Tensor` of rank `Q-1+P-K` with shape:
+
+```
+[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
+```
+
+For example, say we want to add 4 scattered elements to a rank-1 tensor to 8
+elements. In Python, that addition would look like this:
+
+    ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
+    indices = tf.constant([[4], [3], [1], [7]])
+    updates = tf.constant([9, 10, 11, 12])
+    add = tf.scatter_nd_add(ref, indices, updates)
+    with tf.Session() as sess:
+      print sess.run(add)
+
+The resulting update to ref would look like this:
+
+    [1, 13, 3, 14, 14, 6, 7, 20]
+
+See @{tf.scatter_nd} for more details about how to make updates to
+slices.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ScatterNdNonAliasingAdd.pbtxt b/tensorflow/core/api_def/base_api/api_def_ScatterNdNonAliasingAdd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e5c64c2b900773d4ad9975f05f76453c1b8bf0df
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ScatterNdNonAliasingAdd.pbtxt
@@ -0,0 +1,68 @@
+op {
+  graph_op_name: "ScatterNdNonAliasingAdd"
+  in_arg {
+    name: "input"
+    description: <<END
+A Tensor.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A Tensor. Must be one of the following types: `int32`, `int64`.
+A tensor of indices into `input`.
+END
+  }
+  in_arg {
+    name: "updates"
+    description: <<END
+A Tensor. Must have the same type as ref. A tensor of updated values
+to add to `input`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A `Tensor` with the same shape as `input`, containing values of `input`
+updated with `updates`.
+END
+  }
+  summary: "Applies sparse addition to `input` using individual values or slices"
+  description: <<END
+from `updates` according to indices `indices`.  The updates are non-aliasing:
+`input` is only modified in-place if no other operations will use it.
+Otherwise, a copy of `input` is made.  This operation has a gradient with
+respect to both `input` and `updates`.
+
+`input` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
+
+`indices` must be integer tensor, containing indices into `input`.
+It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
+
+The innermost dimension of `indices` (with length `K`) corresponds to
+indices into elements (if `K = P`) or `(P-K)`-dimensional slices
+(if `K < P`) along the `K`th dimension of `input`.
+
+`updates` is `Tensor` of rank `Q-1+P-K` with shape:
+
+```
+[d_0, ..., d_{Q-2}, input.shape[K], ..., input.shape[P-1]].
+```
+
+For example, say we want to add 4 scattered elements to a rank-1 tensor to 8
+elements. In Python, that addition would look like this:
+
+    input = tf.constant([1, 2, 3, 4, 5, 6, 7, 8])
+    indices = tf.constant([[4], [3], [1], [7]])
+    updates = tf.constant([9, 10, 11, 12])
+    output = tf.scatter_nd_non_aliasing_add(input, indices, updates)
+    with tf.Session() as sess:
+      print(sess.run(output))
+
+The resulting value `output` would look like this:
+
+    [1, 13, 3, 14, 14, 6, 7, 20]
+
+See @{tf.scatter_nd} for more details about how to make updates to slices.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ScatterNdSub.pbtxt b/tensorflow/core/api_def/base_api/api_def_ScatterNdSub.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..333db017f56a47a2e3300c508da08caebe33a4f4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ScatterNdSub.pbtxt
@@ -0,0 +1,74 @@
+op {
+  graph_op_name: "ScatterNdSub"
+  in_arg {
+    name: "ref"
+    description: <<END
+A mutable Tensor. Should be from a Variable node.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A Tensor. Must be one of the following types: int32, int64.
+A tensor of indices into ref.
+END
+  }
+  in_arg {
+    name: "updates"
+    description: <<END
+A Tensor. Must have the same type as ref. A tensor of updated values
+to subtract from ref.
+END
+  }
+  out_arg {
+    name: "output_ref"
+    description: <<END
+Same as ref. Returned as a convenience for operations that want
+to use the updated values after the update is done.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+An optional bool. Defaults to True. If True, the assignment will
+be protected by a lock; otherwise the behavior is undefined,
+but may exhibit less contention.
+END
+  }
+  summary: "Applies sparse subtraction between `updates` and individual values or slices"
+  description: <<END
+within a given variable according to `indices`.
+
+`ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
+
+`indices` must be integer tensor, containing indices into `ref`.
+It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
+
+The innermost dimension of `indices` (with length `K`) corresponds to
+indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
+dimension of `ref`.
+
+`updates` is `Tensor` of rank `Q-1+P-K` with shape:
+
+```
+[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
+```
+
+For example, say we want to subtract 4 scattered elements from a rank-1 tensor
+with 8 elements. In Python, that subtraction would look like this:
+
+    ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
+    indices = tf.constant([[4], [3], [1], [7]])
+    updates = tf.constant([9, 10, 11, 12])
+    sub = tf.scatter_nd_sub(ref, indices, updates)
+    with tf.Session() as sess:
+      print sess.run(sub)
+
+The resulting update to ref would look like this:
+
+    [1, -9, 3, -6, -4, 6, 7, -4]
+
+See @{tf.scatter_nd} for more details about how to make updates to
+slices.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ScatterNdUpdate.pbtxt b/tensorflow/core/api_def/base_api/api_def_ScatterNdUpdate.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..33d98262d54da6d50dbb0659cb73fd47cf9f13d2
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ScatterNdUpdate.pbtxt
@@ -0,0 +1,76 @@
+op {
+  graph_op_name: "ScatterNdUpdate"
+  in_arg {
+    name: "ref"
+    description: <<END
+A mutable Tensor. Should be from a Variable node.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A Tensor. Must be one of the following types: int32, int64.
+A tensor of indices into ref.
+END
+  }
+  in_arg {
+    name: "updates"
+    description: <<END
+A Tensor. Must have the same type as ref. A tensor of updated
+values to add to ref.
+END
+  }
+  out_arg {
+    name: "output_ref"
+    description: <<END
+Same as ref. Returned as a convenience for operations that want to
+use the updated values after the update is done.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+An optional bool. Defaults to True. If True, the assignment will
+be protected by a lock; otherwise the behavior is undefined,
+but may exhibit less contention.
+END
+  }
+  summary: "Applies sparse `updates` to individual values or slices within a given"
+  description: <<END
+variable according to `indices`.
+
+`ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
+
+`indices` must be integer tensor, containing indices into `ref`.
+It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
+
+The innermost dimension of `indices` (with length `K`) corresponds to
+indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
+dimension of `ref`.
+
+`updates` is `Tensor` of rank `Q-1+P-K` with shape:
+
+```
+[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
+```
+
+For example, say we want to update 4 scattered elements to a rank-1 tensor to
+8 elements. In Python, that update would look like this:
+
+```python
+    ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
+    indices = tf.constant([[4], [3], [1] ,[7]])
+    updates = tf.constant([9, 10, 11, 12])
+    update = tf.scatter_nd_update(ref, indices, updates)
+    with tf.Session() as sess:
+      print sess.run(update)
+```
+
+The resulting update to ref would look like this:
+
+    [1, 11, 3, 10, 9, 6, 7, 12]
+
+See @{tf.scatter_nd} for more details about how to make updates to
+slices.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ScatterSub.pbtxt b/tensorflow/core/api_def/base_api/api_def_ScatterSub.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c0d3a4a1337ee1e1a32114adc51c930e014bc268
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ScatterSub.pbtxt
@@ -0,0 +1,60 @@
+op {
+  graph_op_name: "ScatterSub"
+  in_arg {
+    name: "ref"
+    description: <<END
+Should be from a `Variable` node.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A tensor of indices into the first dimension of `ref`.
+END
+  }
+  in_arg {
+    name: "updates"
+    description: <<END
+A tensor of updated values to subtract from `ref`.
+END
+  }
+  out_arg {
+    name: "output_ref"
+    description: <<END
+= Same as `ref`.  Returned as a convenience for operations that want
+to use the updated values after the update is done.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, the subtraction will be protected by a lock;
+otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Subtracts sparse updates to a variable reference."
+  description: <<END
+```python
+    # Scalar indices
+    ref[indices, ...] -= updates[...]
+
+    # Vector indices (for each i)
+    ref[indices[i], ...] -= updates[i, ...]
+
+    # High rank indices (for each i, ..., j)
+    ref[indices[i, ..., j], ...] -= updates[i, ..., j, ...]
+```
+
+This operation outputs `ref` after the update is done.
+This makes it easier to chain operations that need to use the reset value.
+
+Duplicate entries are handled correctly: if multiple `indices` reference
+the same location, their (negated) contributions add.
+
+Requires `updates.shape = indices.shape + ref.shape[1:]`.
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src="https://www.tensorflow.org/images/ScatterSub.png" alt>
+</div>
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ScatterUpdate.pbtxt b/tensorflow/core/api_def/base_api/api_def_ScatterUpdate.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c44dbbd2332828242792d9cdd4a218e7457c7d2b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ScatterUpdate.pbtxt
@@ -0,0 +1,63 @@
+op {
+  graph_op_name: "ScatterUpdate"
+  in_arg {
+    name: "ref"
+    description: <<END
+Should be from a `Variable` node.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A tensor of indices into the first dimension of `ref`.
+END
+  }
+  in_arg {
+    name: "updates"
+    description: <<END
+A tensor of updated values to store in `ref`.
+END
+  }
+  out_arg {
+    name: "output_ref"
+    description: <<END
+= Same as `ref`.  Returned as a convenience for operations that want
+to use the updated values after the update is done.
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, the assignment will be protected by a lock;
+otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Applies sparse updates to a variable reference."
+  description: <<END
+This operation computes
+
+```python
+    # Scalar indices
+    ref[indices, ...] = updates[...]
+
+    # Vector indices (for each i)
+    ref[indices[i], ...] = updates[i, ...]
+
+    # High rank indices (for each i, ..., j)
+    ref[indices[i, ..., j], ...] = updates[i, ..., j, ...]
+```
+
+This operation outputs `ref` after the update is done.
+This makes it easier to chain operations that need to use the reset value.
+
+If values in `ref` is to be updated more than once, because there are
+duplicate entries in `indices`, the order at which the updates happen
+for each value is undefined.
+
+Requires `updates.shape = indices.shape + ref.shape[1:]`.
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src="https://www.tensorflow.org/images/ScatterUpdate.png" alt>
+</div>
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SdcaFprint.pbtxt b/tensorflow/core/api_def/base_api/api_def_SdcaFprint.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..829840d04aaf089b75e1ce1940f06c991e93c615
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SdcaFprint.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "SdcaFprint"
+  in_arg {
+    name: "input"
+    description: <<END
+vector of strings to compute fingerprints on.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+a (N,2) shaped matrix where N is the number of elements in the input
+vector. Each row contains the low and high parts of the fingerprint.
+END
+  }
+  summary: "Computes fingerprints of the input strings."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SdcaOptimizer.pbtxt b/tensorflow/core/api_def/base_api/api_def_SdcaOptimizer.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b0b58ac00e6709922ed517ad2c9efebbedf450a3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SdcaOptimizer.pbtxt
@@ -0,0 +1,167 @@
+op {
+  graph_op_name: "SdcaOptimizer"
+  in_arg {
+    name: "sparse_example_indices"
+    description: <<END
+a list of vectors which contain example indices.
+END
+  }
+  in_arg {
+    name: "sparse_feature_indices"
+    description: <<END
+a list of vectors which contain feature indices.
+END
+  }
+  in_arg {
+    name: "sparse_feature_values"
+    description: <<END
+a list of vectors which contains feature value
+associated with each feature group.
+END
+  }
+  in_arg {
+    name: "dense_features"
+    description: <<END
+a list of matrices which contains the dense feature values.
+END
+  }
+  in_arg {
+    name: "example_weights"
+    description: <<END
+a vector which contains the weight associated with each
+example.
+END
+  }
+  in_arg {
+    name: "example_labels"
+    description: <<END
+a vector which contains the label/target associated with each
+example.
+END
+  }
+  in_arg {
+    name: "sparse_indices"
+    description: <<END
+a list of vectors where each value is the indices which has
+corresponding weights in sparse_weights. This field maybe omitted for the
+dense approach.
+END
+  }
+  in_arg {
+    name: "sparse_weights"
+    description: <<END
+a list of vectors where each value is the weight associated with
+a sparse feature group.
+END
+  }
+  in_arg {
+    name: "dense_weights"
+    description: <<END
+a list of vectors where the values are the weights associated
+with a dense feature group.
+END
+  }
+  in_arg {
+    name: "example_state_data"
+    description: <<END
+a list of vectors containing the example state data.
+END
+  }
+  out_arg {
+    name: "out_example_state_data"
+    description: <<END
+a list of vectors containing the updated example state
+data.
+END
+  }
+  out_arg {
+    name: "out_delta_sparse_weights"
+    description: <<END
+a list of vectors where each value is the delta
+weights associated with a sparse feature group.
+END
+  }
+  out_arg {
+    name: "out_delta_dense_weights"
+    description: <<END
+a list of vectors where the values are the delta
+weights associated with a dense feature group.
+END
+  }
+  attr {
+    name: "loss_type"
+    description: <<END
+Type of the primal loss. Currently SdcaSolver supports logistic,
+squared and hinge losses.
+END
+  }
+  attr {
+    name: "adaptative"
+    description: <<END
+Whether to use Adapative SDCA for the inner loop.
+END
+  }
+  attr {
+    name: "num_sparse_features"
+    description: <<END
+Number of sparse feature groups to train on.
+END
+  }
+  attr {
+    name: "num_sparse_features_with_values"
+    description: <<END
+Number of sparse feature groups with values
+associated with it, otherwise implicitly treats values as 1.0.
+END
+  }
+  attr {
+    name: "num_dense_features"
+    description: <<END
+Number of dense feature groups to train on.
+END
+  }
+  attr {
+    name: "l1"
+    description: <<END
+Symmetric l1 regularization strength.
+END
+  }
+  attr {
+    name: "l2"
+    description: <<END
+Symmetric l2 regularization strength.
+END
+  }
+  attr {
+    name: "num_loss_partitions"
+    description: <<END
+Number of partitions of the global loss function.
+END
+  }
+  attr {
+    name: "num_inner_iterations"
+    description: <<END
+Number of iterations per mini-batch.
+END
+  }
+  summary: "Distributed version of Stochastic Dual Coordinate Ascent (SDCA) optimizer for"
+  description: <<END
+linear models with L1 + L2 regularization. As global optimization objective is
+strongly-convex, the optimizer optimizes the dual objective at each step. The
+optimizer applies each update one example at a time. Examples are sampled
+uniformly, and the optimizer is learning rate free and enjoys linear convergence
+rate.
+
+[Proximal Stochastic Dual Coordinate Ascent](http://arxiv.org/pdf/1211.2717v1.pdf).<br>
+Shai Shalev-Shwartz, Tong Zhang. 2012
+
+$$Loss Objective = \sum f_{i} (wx_{i}) + (l2 / 2) * |w|^2 + l1 * |w|$$
+
+[Adding vs. Averaging in Distributed Primal-Dual Optimization](http://arxiv.org/abs/1502.03508).<br>
+Chenxin Ma, Virginia Smith, Martin Jaggi, Michael I. Jordan,
+Peter Richtarik, Martin Takac. 2015
+
+[Stochastic Dual Coordinate Ascent with Adaptive Probabilities](https://arxiv.org/abs/1502.08053).<br>
+Dominik Csiba, Zheng Qu, Peter Richtarik. 2015
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SdcaShrinkL1.pbtxt b/tensorflow/core/api_def/base_api/api_def_SdcaShrinkL1.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8e723c169d91d345931cbed2c4a68a7e45faf8a4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SdcaShrinkL1.pbtxt
@@ -0,0 +1,29 @@
+op {
+  graph_op_name: "SdcaShrinkL1"
+  in_arg {
+    name: "weights"
+    description: <<END
+a list of vectors where each value is the weight associated with a
+feature group.
+END
+  }
+  attr {
+    name: "num_features"
+    description: <<END
+Number of feature groups to apply shrinking step.
+END
+  }
+  attr {
+    name: "l1"
+    description: <<END
+Symmetric l1 regularization strength.
+END
+  }
+  attr {
+    name: "l2"
+    description: <<END
+Symmetric l2 regularization strength. Should be a positive float.
+END
+  }
+  summary: "Applies L1 regularization shrink step on the parameters."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SegmentMax.pbtxt b/tensorflow/core/api_def/base_api/api_def_SegmentMax.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..db890cb2f51256fd9dabaa8aa590ccde37eec343
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SegmentMax.pbtxt
@@ -0,0 +1,32 @@
+op {
+  graph_op_name: "SegmentMax"
+  in_arg {
+    name: "segment_ids"
+    description: <<END
+A 1-D tensor whose rank is equal to the rank of `data`'s
+first dimension.  Values should be sorted and can be repeated.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Has same shape as data, except for dimension 0 which
+has size `k`, the number of segments.
+END
+  }
+  summary: "Computes the maximum along segments of a tensor."
+  description: <<END
+Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
+segments.
+
+Computes a tensor such that
+\\(output_i = \max_j(data_j)\\) where `max` is over `j` such
+that `segment_ids[j] == i`.
+
+If the max is empty for a given segment ID `i`, `output[i] = 0`.
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src="https://www.tensorflow.org/images/SegmentMax.png" alt>
+</div>
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SegmentMean.pbtxt b/tensorflow/core/api_def/base_api/api_def_SegmentMean.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4713c523102a66204bcd4b0480e194ec5d14a420
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SegmentMean.pbtxt
@@ -0,0 +1,33 @@
+op {
+  graph_op_name: "SegmentMean"
+  in_arg {
+    name: "segment_ids"
+    description: <<END
+A 1-D tensor whose rank is equal to the rank of `data`'s
+first dimension.  Values should be sorted and can be repeated.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Has same shape as data, except for dimension 0 which
+has size `k`, the number of segments.
+END
+  }
+  summary: "Computes the mean along segments of a tensor."
+  description: <<END
+Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
+segments.
+
+Computes a tensor such that
+\\(output_i = \frac{\sum_j data_j}{N}\\) where `mean` is
+over `j` such that `segment_ids[j] == i` and `N` is the total number of
+values summed.
+
+If the mean is empty for a given segment ID `i`, `output[i] = 0`.
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src="https://www.tensorflow.org/images/SegmentMean.png" alt>
+</div>
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SegmentMin.pbtxt b/tensorflow/core/api_def/base_api/api_def_SegmentMin.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6316bfd1a5779ca28b4437c0324844b98e819e1a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SegmentMin.pbtxt
@@ -0,0 +1,32 @@
+op {
+  graph_op_name: "SegmentMin"
+  in_arg {
+    name: "segment_ids"
+    description: <<END
+A 1-D tensor whose rank is equal to the rank of `data`'s
+first dimension.  Values should be sorted and can be repeated.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Has same shape as data, except for dimension 0 which
+has size `k`, the number of segments.
+END
+  }
+  summary: "Computes the minimum along segments of a tensor."
+  description: <<END
+Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
+segments.
+
+Computes a tensor such that
+\\(output_i = \min_j(data_j)\\) where `min` is over `j` such
+that `segment_ids[j] == i`.
+
+If the min is empty for a given segment ID `i`, `output[i] = 0`.
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src="https://www.tensorflow.org/images/SegmentMin.png" alt>
+</div>
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SegmentProd.pbtxt b/tensorflow/core/api_def/base_api/api_def_SegmentProd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a16d03d467e9ac70e0752f29e042d50e878114b5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SegmentProd.pbtxt
@@ -0,0 +1,32 @@
+op {
+  graph_op_name: "SegmentProd"
+  in_arg {
+    name: "segment_ids"
+    description: <<END
+A 1-D tensor whose rank is equal to the rank of `data`'s
+first dimension.  Values should be sorted and can be repeated.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Has same shape as data, except for dimension 0 which
+has size `k`, the number of segments.
+END
+  }
+  summary: "Computes the product along segments of a tensor."
+  description: <<END
+Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
+segments.
+
+Computes a tensor such that
+\\(output_i = \prod_j data_j\\) where the product is over `j` such
+that `segment_ids[j] == i`.
+
+If the product is empty for a given segment ID `i`, `output[i] = 1`.
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src="https://www.tensorflow.org/images/SegmentProd.png" alt>
+</div>
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SegmentSum.pbtxt b/tensorflow/core/api_def/base_api/api_def_SegmentSum.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0686e17f9bdeb09076157fd664ddf58766c22560
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SegmentSum.pbtxt
@@ -0,0 +1,32 @@
+op {
+  graph_op_name: "SegmentSum"
+  in_arg {
+    name: "segment_ids"
+    description: <<END
+A 1-D tensor whose rank is equal to the rank of `data`'s
+first dimension.  Values should be sorted and can be repeated.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Has same shape as data, except for dimension 0 which
+has size `k`, the number of segments.
+END
+  }
+  summary: "Computes the sum along segments of a tensor."
+  description: <<END
+Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
+segments.
+
+Computes a tensor such that
+\\(output_i = \sum_j data_j\\) where sum is over `j` such
+that `segment_ids[j] == i`.
+
+If the sum is empty for a given segment ID `i`, `output[i] = 0`.
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src="https://www.tensorflow.org/images/SegmentSum.png" alt>
+</div>
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Select.pbtxt b/tensorflow/core/api_def/base_api/api_def_Select.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..456ea8c01e34ec56917f314ada14dac7ebafbf3c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Select.pbtxt
@@ -0,0 +1,69 @@
+op {
+  graph_op_name: "Select"
+  endpoint {
+    name: "Where3"
+  }
+  in_arg {
+    name: "t"
+    rename_to: "x"
+    description: <<END
+= A `Tensor` which may have the same shape as `condition`.
+If `condition` is rank 1, `t` may have higher rank,
+but its first dimension must match the size of `condition`.
+END
+  }
+  in_arg {
+    name: "e"
+    rename_to: "y"
+    description: <<END
+= A `Tensor` with the same type and shape as `t`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+= A `Tensor` with the same type and shape as `t` and `e`.
+END
+  }
+  summary: "Selects elements from `t` or `e`, depending on `condition`."
+  description: <<END
+The `t`, and `e` tensors must all have the same shape, and the
+output will also have that shape.
+
+The `condition` tensor must be a scalar if `t` and `e` are scalars.
+If `t` and `e` are vectors or higher rank, then `condition` must be either a
+scalar, a vector with size matching the first dimension of `t`, or must have
+the same shape as `t`.
+
+The `condition` tensor acts as a mask that chooses, based on the value at each
+element, whether the corresponding element / row in the output should be
+taken from `t` (if true) or `e` (if false).
+
+If `condition` is a vector and `t` and `e` are higher rank matrices, then
+it chooses which row (outer dimension) to copy from `t` and `e`.
+If `condition` has the same shape as `t` and `e`, then it chooses which
+element to copy from `t` and `e`.
+
+For example:
+
+```python
+# 'condition' tensor is [[True,  False]
+#                        [False, True]]
+# 't' is [[1, 2],
+#         [3, 4]]
+# 'e' is [[5, 6],
+#         [7, 8]]
+select(condition, t, e)  # => [[1, 6], [7, 4]]
+
+
+# 'condition' tensor is [True, False]
+# 't' is [[1, 2],
+#         [3, 4]]
+# 'e' is [[5, 6],
+#         [7, 8]]
+select(condition, t, e) ==> [[1, 2],
+                             [7, 8]]
+
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SelfAdjointEig.pbtxt b/tensorflow/core/api_def/base_api/api_def_SelfAdjointEig.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..51d63eeb5695d6a428e990ba43e54102db58b58e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SelfAdjointEig.pbtxt
@@ -0,0 +1,24 @@
+op {
+  graph_op_name: "SelfAdjointEig"
+  in_arg {
+    name: "input"
+    description: <<END
+Shape is `[..., M, M]`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Shape is `[..., M+1, M]`.
+END
+  }
+  summary: "Computes the Eigen Decomposition of a batch of square self-adjoint matrices."
+  description: <<END
+The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+form square matrices, with the same constraints as the single matrix
+SelfAdjointEig.
+
+The result is a [..., M+1, M] matrix with [..., 0,:] containing the
+eigenvalues, and subsequent [...,1:, :] containing the eigenvectors.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SelfAdjointEigV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_SelfAdjointEigV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4a5e1252586ea8b3e03b2545e0d8646288ddc408
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SelfAdjointEigV2.pbtxt
@@ -0,0 +1,44 @@
+op {
+  graph_op_name: "SelfAdjointEigV2"
+  endpoint {
+    name: "SelfAdjointEig"
+  }
+  in_arg {
+    name: "input"
+    description: <<END
+`Tensor` input of shape `[N, N]`.
+END
+  }
+  out_arg {
+    name: "e"
+    description: <<END
+Eigenvalues. Shape is `[N]`.
+END
+  }
+  out_arg {
+    name: "v"
+    description: <<END
+Eigenvectors. Shape is `[N, N]`.
+END
+  }
+  attr {
+    name: "compute_v"
+    description: <<END
+If `True` then eigenvectors will be computed and returned in `v`.
+Otherwise, only the eigenvalues will be computed.
+END
+  }
+  summary: "Computes the eigen decomposition of one or more square self-adjoint matrices."
+  description: <<END
+Computes the eigenvalues and (optionally) eigenvectors of each inner matrix in
+`input` such that `input[..., :, :] = v[..., :, :] * diag(e[..., :])`.
+
+```python
+# a is a tensor.
+# e is a tensor of eigenvalues.
+# v is a tensor of eigenvectors.
+e, v = self_adjoint_eig(a)
+e = self_adjoint_eig(a, compute_v=False)
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Selu.pbtxt b/tensorflow/core/api_def/base_api/api_def_Selu.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cbe76de415125663ff47d3f0fac99f27ad029086
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Selu.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "Selu"
+  summary: "Computes scaled exponential linear: `scale * alpha * (exp(features) - 1)`"
+  description: <<END
+if < 0, `scale * features` otherwise.
+
+See [Self-Normalizing Neural Networks](https://arxiv.org/abs/1706.02515)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SeluGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_SeluGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b5180b73d299eeaf7cbe09493c129f68dee295f3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SeluGrad.pbtxt
@@ -0,0 +1,24 @@
+op {
+  graph_op_name: "SeluGrad"
+  visibility: HIDDEN
+  in_arg {
+    name: "gradients"
+    description: <<END
+The backpropagated gradients to the corresponding Selu operation.
+END
+  }
+  in_arg {
+    name: "outputs"
+    description: <<END
+The outputs of the corresponding Selu operation.
+END
+  }
+  out_arg {
+    name: "backprops"
+    description: <<END
+The gradients: `gradients * (outputs + scale * alpha)`
+if outputs < 0, `scale * gradients` otherwise.
+END
+  }
+  summary: "Computes gradients for the scaled exponential linear (Selu) operation."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SerializeIterator.pbtxt b/tensorflow/core/api_def/base_api/api_def_SerializeIterator.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e24b122006980e0f99e8a76cc317b1f45cec1d68
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SerializeIterator.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "SerializeIterator"
+  in_arg {
+    name: "resource_handle"
+    description: <<END
+A handle to an iterator resource.
+END
+  }
+  out_arg {
+    name: "serialized"
+    description: <<END
+A variant tensor storing the state of the iterator contained in the
+resource.
+END
+  }
+  summary: "Converts the given `resource_handle` representing an iterator to a variant tensor."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SerializeManySparse.pbtxt b/tensorflow/core/api_def/base_api/api_def_SerializeManySparse.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0010bca0b017bcaac5552f7aa9462b0c56d4c01a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SerializeManySparse.pbtxt
@@ -0,0 +1,31 @@
+op {
+  graph_op_name: "SerializeManySparse"
+  in_arg {
+    name: "sparse_indices"
+    description: <<END
+2-D.  The `indices` of the minibatch `SparseTensor`.
+END
+  }
+  in_arg {
+    name: "sparse_values"
+    description: <<END
+1-D.  The `values` of the minibatch `SparseTensor`.
+END
+  }
+  in_arg {
+    name: "sparse_shape"
+    description: <<END
+1-D.  The `shape` of the minibatch `SparseTensor`.
+END
+  }
+  summary: "Serialize an `N`-minibatch `SparseTensor` into an `[N, 3]` string `Tensor`."
+  description: <<END
+The `SparseTensor` must have rank `R` greater than 1, and the first dimension
+is treated as the minibatch dimension.  Elements of the `SparseTensor`
+must be sorted in increasing order of this first dimension.  The serialized
+`SparseTensor` objects going into each row of `serialized_sparse` will have
+rank `R-1`.
+
+The minibatch size `N` is extracted from `sparse_shape[0]`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SerializeSparse.pbtxt b/tensorflow/core/api_def/base_api/api_def_SerializeSparse.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bb4a352d489c597b6e953bc79e307b0d74042e14
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SerializeSparse.pbtxt
@@ -0,0 +1,22 @@
+op {
+  graph_op_name: "SerializeSparse"
+  in_arg {
+    name: "sparse_indices"
+    description: <<END
+2-D.  The `indices` of the `SparseTensor`.
+END
+  }
+  in_arg {
+    name: "sparse_values"
+    description: <<END
+1-D.  The `values` of the `SparseTensor`.
+END
+  }
+  in_arg {
+    name: "sparse_shape"
+    description: <<END
+1-D.  The `shape` of the `SparseTensor`.
+END
+  }
+  summary: "Serialize a `SparseTensor` into a string 3-vector (1-D `Tensor`) object."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SerializeTensor.pbtxt b/tensorflow/core/api_def/base_api/api_def_SerializeTensor.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..48f7ba7aa14823d1eaa02bc100aed8d17298d9c8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SerializeTensor.pbtxt
@@ -0,0 +1,22 @@
+op {
+  graph_op_name: "SerializeTensor"
+  in_arg {
+    name: "tensor"
+    description: <<END
+A Tensor of type `T`.
+END
+  }
+  out_arg {
+    name: "serialized"
+    description: <<END
+A serialized TensorProto proto of the input tensor.
+END
+  }
+  attr {
+    name: "T"
+    description: <<END
+The type of the input tensor.
+END
+  }
+  summary: "Transforms a Tensor into a serialized TensorProto proto."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SetSize.pbtxt b/tensorflow/core/api_def/base_api/api_def_SetSize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..812537412e20c800042e268c04d55aa4c32912cd
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SetSize.pbtxt
@@ -0,0 +1,38 @@
+op {
+  graph_op_name: "SetSize"
+  in_arg {
+    name: "set_indices"
+    description: <<END
+2D `Tensor`, indices of a `SparseTensor`.
+END
+  }
+  in_arg {
+    name: "set_values"
+    description: <<END
+1D `Tensor`, values of a `SparseTensor`.
+END
+  }
+  in_arg {
+    name: "set_shape"
+    description: <<END
+1D `Tensor`, shape of a `SparseTensor`.
+END
+  }
+  out_arg {
+    name: "size"
+    description: <<END
+For `set` ranked `n`, this is a `Tensor` with rank `n-1`, and the same 1st
+`n-1` dimensions as `set`. Each value is the number of unique elements in
+the corresponding `[0...n-1]` dimension of `set`.
+END
+  }
+  summary: "Number of unique elements along last dimension of input `set`."
+  description: <<END
+Input `set` is a `SparseTensor` represented by `set_indices`, `set_values`,
+and `set_shape`. The last dimension contains values in a set, duplicates are
+allowed but ignored.
+
+If `validate_indices` is `True`, this op validates the order and range of `set`
+indices.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Shape.pbtxt b/tensorflow/core/api_def/base_api/api_def_Shape.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4efb5384e09efd13045597a0187930ba6a8aa67a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Shape.pbtxt
@@ -0,0 +1,14 @@
+op {
+  graph_op_name: "Shape"
+  summary: "Returns the shape of a tensor."
+  description: <<END
+This operation returns a 1-D integer tensor representing the shape of `input`.
+
+For example:
+
+```
+# 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
+shape(t) ==> [2, 2, 3]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ShapeN.pbtxt b/tensorflow/core/api_def/base_api/api_def_ShapeN.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..aa38320f9b42de2429679cb099baa9fdc5db6f02
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ShapeN.pbtxt
@@ -0,0 +1,7 @@
+op {
+  graph_op_name: "ShapeN"
+  summary: "Returns shape of tensors."
+  description: <<END
+This operation returns N 1-D integer tensors representing shape of `input[i]s`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ShardedFilename.pbtxt b/tensorflow/core/api_def/base_api/api_def_ShardedFilename.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..11d1352918630044b4adac1423700f9c9967d328
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ShardedFilename.pbtxt
@@ -0,0 +1,7 @@
+op {
+  graph_op_name: "ShardedFilename"
+  summary: "Generate a sharded filename. The filename is printf formatted as"
+  description: <<END
+   %s-%05d-of-%05d, basename, shard, num_shards.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ShardedFilespec.pbtxt b/tensorflow/core/api_def/base_api/api_def_ShardedFilespec.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ecf0a091e2070a444ec8c1bf788142a4e3db39c0
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ShardedFilespec.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ShardedFilespec"
+  summary: "Generate a glob pattern matching all sharded file names."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ShuffleDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_ShuffleDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b12d3af9d74411fb46fb50d7dba57b7e60bbe933
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ShuffleDataset.pbtxt
@@ -0,0 +1,36 @@
+op {
+  graph_op_name: "ShuffleDataset"
+  in_arg {
+    name: "buffer_size"
+    description: <<END
+The number of output elements to buffer in an iterator over
+this dataset. Compare with the `min_after_dequeue` attr when creating a
+`RandomShuffleQueue`.
+END
+  }
+  in_arg {
+    name: "seed"
+    description: <<END
+A scalar seed for the random number generator. If either seed or
+seed2 is set to be non-zero, the random number generator is seeded
+by the given seed.  Otherwise, a random seed is used.
+END
+  }
+  in_arg {
+    name: "seed2"
+    description: <<END
+A second scalar seed to avoid seed collision.
+END
+  }
+  attr {
+    name: "reshuffle_each_iteration"
+    description: <<END
+If true, each iterator over this dataset will be given
+a different pseudorandomly generated seed, based on a sequence seeded by the
+`seed` and `seed2` inputs. If false, each iterator will be given the same
+seed, and repeated iteration over this dataset will yield the exact same
+sequence of results.
+END
+  }
+  summary: "Creates a dataset that shuffles elements from `input_dataset` pseudorandomly."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Sigmoid.pbtxt b/tensorflow/core/api_def/base_api/api_def_Sigmoid.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..300ab0cde6980b6c4262f7809ac74f41a1080e3f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Sigmoid.pbtxt
@@ -0,0 +1,7 @@
+op {
+  graph_op_name: "Sigmoid"
+  summary: "Computes sigmoid of `x` element-wise."
+  description: <<END
+Specifically, `y = 1 / (1 + exp(-x))`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SigmoidGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_SigmoidGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..911d6c5eeeb9b202f4192e4abb12c9ea5373c096
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SigmoidGrad.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "SigmoidGrad"
+  visibility: HIDDEN
+  summary: "Computes the gradient of the sigmoid of `x` wrt its input."
+  description: <<END
+Specifically, `grad = dy * y * (1 - y)`, where `y = sigmoid(x)`, and
+`dy` is the corresponding input gradient.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Sign.pbtxt b/tensorflow/core/api_def/base_api/api_def_Sign.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4eb4be1a7580a7d51733512508488feb9d934342
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Sign.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "Sign"
+  summary: "Returns an element-wise indication of the sign of a number."
+  description: <<END
+`y = sign(x) = -1` if `x < 0`; 0 if `x == 0`; 1 if `x > 0`.
+
+For complex numbers, `y = sign(x) = x / |x|` if `x != 0`, otherwise `y = 0`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Sin.pbtxt b/tensorflow/core/api_def/base_api/api_def_Sin.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f4edefb66d461de495c296cf417a528d65993d90
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Sin.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Sin"
+  summary: "Computes sin of x element-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Sinh.pbtxt b/tensorflow/core/api_def/base_api/api_def_Sinh.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a6784e8a59e87b5bfc9e760631cc1e95fff18983
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Sinh.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Sinh"
+  summary: "Computes hyperbolic sine of x element-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Size.pbtxt b/tensorflow/core/api_def/base_api/api_def_Size.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6e6cb330859f5e33e8b91ba7b871545676e95234
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Size.pbtxt
@@ -0,0 +1,15 @@
+op {
+  graph_op_name: "Size"
+  summary: "Returns the size of a tensor."
+  description: <<END
+This operation returns an integer representing the number of elements in
+`input`.
+
+For example:
+
+```
+# 't' is [[[1, 1,, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]]
+size(t) ==> 12
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SkipDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_SkipDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..44e5bac79b8cdfb703d8679b66d79ab9e9e7509a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SkipDataset.pbtxt
@@ -0,0 +1,11 @@
+op {
+  graph_op_name: "SkipDataset"
+  in_arg {
+    name: "count"
+    description: <<END
+A scalar representing the number of elements from the `input_dataset`
+that should be skipped.  If count is -1, skips everything.
+END
+  }
+  summary: "Creates a dataset that skips `count` elements from the `input_dataset`."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Skipgram.pbtxt b/tensorflow/core/api_def/base_api/api_def_Skipgram.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d6829540177efc4239d96bbc467af9005e7ad178
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Skipgram.pbtxt
@@ -0,0 +1,78 @@
+op {
+  graph_op_name: "Skipgram"
+  out_arg {
+    name: "vocab_word"
+    description: <<END
+A vector of words in the corpus.
+END
+  }
+  out_arg {
+    name: "vocab_freq"
+    description: <<END
+Frequencies of words. Sorted in the non-ascending order.
+END
+  }
+  out_arg {
+    name: "words_per_epoch"
+    description: <<END
+Number of words per epoch in the data file.
+END
+  }
+  out_arg {
+    name: "current_epoch"
+    description: <<END
+The current epoch number.
+END
+  }
+  out_arg {
+    name: "total_words_processed"
+    description: <<END
+The total number of words processed so far.
+END
+  }
+  out_arg {
+    name: "examples"
+    description: <<END
+A vector of word ids.
+END
+  }
+  out_arg {
+    name: "labels"
+    description: <<END
+A vector of word ids.
+END
+  }
+  attr {
+    name: "filename"
+    description: <<END
+The corpus's text file name.
+END
+  }
+  attr {
+    name: "batch_size"
+    description: <<END
+The size of produced batch.
+END
+  }
+  attr {
+    name: "window_size"
+    description: <<END
+The number of words to predict to the left and right of the target.
+END
+  }
+  attr {
+    name: "min_count"
+    description: <<END
+The minimum number of word occurrences for it to be included in the
+vocabulary.
+END
+  }
+  attr {
+    name: "subsample"
+    description: <<END
+Threshold for word occurrence. Words that appear with higher
+frequency will be randomly down-sampled. Set to 0 to disable.
+END
+  }
+  summary: "Parses a text file and creates a batch of examples."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Slice.pbtxt b/tensorflow/core/api_def/base_api/api_def_Slice.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bd6ad26d1b3dd3ae4190e710ca4ee2ba62846242
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Slice.pbtxt
@@ -0,0 +1,28 @@
+op {
+  graph_op_name: "Slice"
+  in_arg {
+    name: "begin"
+    description: <<END
+begin[i] specifies the offset into the 'i'th dimension of
+'input' to slice from.
+END
+  }
+  in_arg {
+    name: "size"
+    description: <<END
+size[i] specifies the number of elements of the 'i'th dimension
+of 'input' to slice. If size[i] is -1, all remaining elements in dimension
+i are included in the slice (i.e. this is equivalent to setting
+size[i] = input.dim_size(i) - begin[i]).
+END
+  }
+  summary: "Return a slice from \'input\'."
+  description: <<END
+The output tensor is a tensor with dimensions described by 'size'
+whose values are extracted from 'input' starting at the offsets in
+'begin'.
+
+*Requirements*:
+  0 <= begin[i] <= begin[i] + size[i] <= Di  for i in [0, n)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Softmax.pbtxt b/tensorflow/core/api_def/base_api/api_def_Softmax.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..43884824c9e6e65491e51c6953f2e35eb19bd634
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Softmax.pbtxt
@@ -0,0 +1,21 @@
+op {
+  graph_op_name: "Softmax"
+  in_arg {
+    name: "logits"
+    description: <<END
+2-D with shape `[batch_size, num_classes]`.
+END
+  }
+  out_arg {
+    name: "softmax"
+    description: <<END
+Same shape as `logits`.
+END
+  }
+  summary: "Computes softmax activations."
+  description: <<END
+For each batch `i` and class `j` we have
+
+    softmax[i, j] = exp(logits[i, j]) / sum_j(exp(logits[i, j]))
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SoftmaxCrossEntropyWithLogits.pbtxt b/tensorflow/core/api_def/base_api/api_def_SoftmaxCrossEntropyWithLogits.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..973fbb8f6c4469429446562a4db3ae89fdc75b28
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SoftmaxCrossEntropyWithLogits.pbtxt
@@ -0,0 +1,33 @@
+op {
+  graph_op_name: "SoftmaxCrossEntropyWithLogits"
+  in_arg {
+    name: "features"
+    description: <<END
+batch_size x num_classes matrix
+END
+  }
+  in_arg {
+    name: "labels"
+    description: <<END
+batch_size x num_classes matrix
+The caller must ensure that each batch of labels represents a valid
+probability distribution.
+END
+  }
+  out_arg {
+    name: "loss"
+    description: <<END
+Per example loss (batch_size vector).
+END
+  }
+  out_arg {
+    name: "backprop"
+    description: <<END
+backpropagated gradients (batch_size x num_classes matrix).
+END
+  }
+  summary: "Computes softmax cross entropy cost and gradients to backpropagate."
+  description: <<END
+Inputs are the logits, not probabilities.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Softplus.pbtxt b/tensorflow/core/api_def/base_api/api_def_Softplus.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..83f6aad87759620fa061d9cffd94b7ccd9a20b20
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Softplus.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Softplus"
+  summary: "Computes softplus: `log(exp(features) + 1)`."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SoftplusGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_SoftplusGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..96e4d8cb5ad36ddcc2c3730f6efeb8066da13bd4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SoftplusGrad.pbtxt
@@ -0,0 +1,23 @@
+op {
+  graph_op_name: "SoftplusGrad"
+  visibility: HIDDEN
+  in_arg {
+    name: "gradients"
+    description: <<END
+The backpropagated gradients to the corresponding softplus operation.
+END
+  }
+  in_arg {
+    name: "features"
+    description: <<END
+The features passed as input to the corresponding softplus operation.
+END
+  }
+  out_arg {
+    name: "backprops"
+    description: <<END
+The gradients: `gradients / (1 + exp(-features))`.
+END
+  }
+  summary: "Computes softplus gradients for a softplus operation."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Softsign.pbtxt b/tensorflow/core/api_def/base_api/api_def_Softsign.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1ae451ec44ff55fdf7e2165a7b6b64dab100c4ee
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Softsign.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Softsign"
+  summary: "Computes softsign: `features / (abs(features) + 1)`."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SoftsignGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_SoftsignGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..23696f12a1adad25ad1df4c0dcc434e76e206078
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SoftsignGrad.pbtxt
@@ -0,0 +1,23 @@
+op {
+  graph_op_name: "SoftsignGrad"
+  visibility: HIDDEN
+  in_arg {
+    name: "gradients"
+    description: <<END
+The backpropagated gradients to the corresponding softsign operation.
+END
+  }
+  in_arg {
+    name: "features"
+    description: <<END
+The features passed as input to the corresponding softsign operation.
+END
+  }
+  out_arg {
+    name: "backprops"
+    description: <<END
+The gradients: `gradients / (1 + abs(features)) ** 2`.
+END
+  }
+  summary: "Computes softsign gradients for a softsign operation."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SpaceToBatch.pbtxt b/tensorflow/core/api_def/base_api/api_def_SpaceToBatch.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..de6182807a74132f743cf40dea8c6c6633ac7f13
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SpaceToBatch.pbtxt
@@ -0,0 +1,109 @@
+op {
+  graph_op_name: "SpaceToBatch"
+  in_arg {
+    name: "input"
+    description: <<END
+4-D with shape `[batch, height, width, depth]`.
+END
+  }
+  in_arg {
+    name: "paddings"
+    description: <<END
+2-D tensor of non-negative integers with shape `[2, 2]`. It specifies
+  the padding of the input with zeros across the spatial dimensions as follows:
+
+      paddings = [[pad_top, pad_bottom], [pad_left, pad_right]]
+
+  The effective spatial dimensions of the zero-padded input tensor will be:
+
+      height_pad = pad_top + height + pad_bottom
+      width_pad = pad_left + width + pad_right
+
+The attr `block_size` must be greater than one. It indicates the block size.
+
+  * Non-overlapping blocks of size `block_size x block size` in the height and
+    width dimensions are rearranged into the batch dimension at each location.
+  * The batch of the output tensor is `batch * block_size * block_size`.
+  * Both height_pad and width_pad must be divisible by block_size.
+
+The shape of the output will be:
+
+    [batch*block_size*block_size, height_pad/block_size, width_pad/block_size,
+     depth]
+
+Some examples:
+
+(1) For the following input of shape `[1, 2, 2, 1]` and block_size of 2:
+
+```
+x = [[[[1], [2]], [[3], [4]]]]
+```
+
+The output tensor has shape `[4, 1, 1, 1]` and value:
+
+```
+[[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
+```
+
+(2) For the following input of shape `[1, 2, 2, 3]` and block_size of 2:
+
+```
+x = [[[[1, 2, 3], [4, 5, 6]],
+      [[7, 8, 9], [10, 11, 12]]]]
+```
+
+The output tensor has shape `[4, 1, 1, 3]` and value:
+
+```
+[[[1, 2, 3]], [[4, 5, 6]], [[7, 8, 9]], [[10, 11, 12]]]
+```
+
+(3) For the following input of shape `[1, 4, 4, 1]` and block_size of 2:
+
+```
+x = [[[[1],   [2],  [3],  [4]],
+      [[5],   [6],  [7],  [8]],
+      [[9],  [10], [11],  [12]],
+      [[13], [14], [15],  [16]]]]
+```
+
+The output tensor has shape `[4, 2, 2, 1]` and value:
+
+```
+x = [[[[1], [3]], [[9], [11]]],
+     [[[2], [4]], [[10], [12]]],
+     [[[5], [7]], [[13], [15]]],
+     [[[6], [8]], [[14], [16]]]]
+```
+
+(4) For the following input of shape `[2, 2, 4, 1]` and block_size of 2:
+
+```
+x = [[[[1],   [2],  [3],  [4]],
+      [[5],   [6],  [7],  [8]]],
+     [[[9],  [10], [11],  [12]],
+      [[13], [14], [15],  [16]]]]
+```
+
+The output tensor has shape `[8, 1, 2, 1]` and value:
+
+```
+x = [[[[1], [3]]], [[[9], [11]]], [[[2], [4]]], [[[10], [12]]],
+     [[[5], [7]]], [[[13], [15]]], [[[6], [8]]], [[[14], [16]]]]
+```
+
+Among others, this operation is useful for reducing atrous convolution into
+regular convolution.
+END
+  }
+  summary: "SpaceToBatch for 4-D tensors of type T."
+  description: <<END
+This is a legacy version of the more general SpaceToBatchND.
+
+Zero-pads and then rearranges (permutes) blocks of spatial data into batch.
+More specifically, this op outputs a copy of the input tensor where values from
+the `height` and `width` dimensions are moved to the `batch` dimension. After
+the zero-padding, both `height` and `width` of the input must be divisible by the
+block size.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SpaceToBatchND.pbtxt b/tensorflow/core/api_def/base_api/api_def_SpaceToBatchND.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2c5e33791984b2e5dba336b43d967b14120b4ae7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SpaceToBatchND.pbtxt
@@ -0,0 +1,140 @@
+op {
+  graph_op_name: "SpaceToBatchND"
+  in_arg {
+    name: "input"
+    description: <<END
+N-D with shape `input_shape = [batch] + spatial_shape + remaining_shape`,
+where spatial_shape has `M` dimensions.
+END
+  }
+  in_arg {
+    name: "block_shape"
+    description: <<END
+1-D with shape `[M]`, all values must be >= 1.
+END
+  }
+  in_arg {
+    name: "paddings"
+    description: <<END
+2-D with shape `[M, 2]`, all values must be >= 0.
+  `paddings[i] = [pad_start, pad_end]` specifies the padding for input dimension
+  `i + 1`, which corresponds to spatial dimension `i`.  It is required that
+  `block_shape[i]` divides `input_shape[i + 1] + pad_start + pad_end`.
+
+This operation is equivalent to the following steps:
+
+1. Zero-pad the start and end of dimensions `[1, ..., M]` of the
+   input according to `paddings` to produce `padded` of shape `padded_shape`.
+
+2. Reshape `padded` to `reshaped_padded` of shape:
+
+     [batch] +
+     [padded_shape[1] / block_shape[0],
+       block_shape[0],
+      ...,
+      padded_shape[M] / block_shape[M-1],
+      block_shape[M-1]] +
+     remaining_shape
+
+3. Permute dimensions of `reshaped_padded` to produce
+   `permuted_reshaped_padded` of shape:
+
+     block_shape +
+     [batch] +
+     [padded_shape[1] / block_shape[0],
+      ...,
+      padded_shape[M] / block_shape[M-1]] +
+     remaining_shape
+
+4. Reshape `permuted_reshaped_padded` to flatten `block_shape` into the batch
+   dimension, producing an output tensor of shape:
+
+     [batch * prod(block_shape)] +
+     [padded_shape[1] / block_shape[0],
+      ...,
+      padded_shape[M] / block_shape[M-1]] +
+     remaining_shape
+
+Some examples:
+
+(1) For the following input of shape `[1, 2, 2, 1]`, `block_shape = [2, 2]`, and
+    `paddings = [[0, 0], [0, 0]]`:
+
+```
+x = [[[[1], [2]], [[3], [4]]]]
+```
+
+The output tensor has shape `[4, 1, 1, 1]` and value:
+
+```
+[[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
+```
+
+(2) For the following input of shape `[1, 2, 2, 3]`, `block_shape = [2, 2]`, and
+    `paddings = [[0, 0], [0, 0]]`:
+
+```
+x = [[[[1, 2, 3], [4, 5, 6]],
+      [[7, 8, 9], [10, 11, 12]]]]
+```
+
+The output tensor has shape `[4, 1, 1, 3]` and value:
+
+```
+[[[1, 2, 3]], [[4, 5, 6]], [[7, 8, 9]], [[10, 11, 12]]]
+```
+
+(3) For the following input of shape `[1, 4, 4, 1]`, `block_shape = [2, 2]`, and
+    `paddings = [[0, 0], [0, 0]]`:
+
+```
+x = [[[[1],   [2],  [3],  [4]],
+      [[5],   [6],  [7],  [8]],
+      [[9],  [10], [11],  [12]],
+      [[13], [14], [15],  [16]]]]
+```
+
+The output tensor has shape `[4, 2, 2, 1]` and value:
+
+```
+x = [[[[1], [3]], [[9], [11]]],
+     [[[2], [4]], [[10], [12]]],
+     [[[5], [7]], [[13], [15]]],
+     [[[6], [8]], [[14], [16]]]]
+```
+
+(4) For the following input of shape `[2, 2, 4, 1]`, block_shape = `[2, 2]`, and
+    paddings = `[[0, 0], [2, 0]]`:
+
+```
+x = [[[[1],   [2],  [3],  [4]],
+      [[5],   [6],  [7],  [8]]],
+     [[[9],  [10], [11],  [12]],
+      [[13], [14], [15],  [16]]]]
+```
+
+The output tensor has shape `[8, 1, 3, 1]` and value:
+
+```
+x = [[[[0], [1], [3]]], [[[0], [9], [11]]],
+     [[[0], [2], [4]]], [[[0], [10], [12]]],
+     [[[0], [5], [7]]], [[[0], [13], [15]]],
+     [[[0], [6], [8]]], [[[0], [14], [16]]]]
+```
+
+Among others, this operation is useful for reducing atrous convolution into
+regular convolution.
+END
+  }
+  summary: "SpaceToBatch for N-D tensors of type T."
+  description: <<END
+This operation divides "spatial" dimensions `[1, ..., M]` of the input into a
+grid of blocks of shape `block_shape`, and interleaves these blocks with the
+"batch" dimension (0) such that in the output, the spatial dimensions
+`[1, ..., M]` correspond to the position within the grid, and the batch
+dimension combines both the position within a spatial block and the original
+batch position.  Prior to division into blocks, the spatial dimensions of the
+input are optionally zero padded according to `paddings`.  See below for a
+precise description.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SpaceToDepth.pbtxt b/tensorflow/core/api_def/base_api/api_def_SpaceToDepth.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8fd3966f7038a507ea3402e300f9362bd4f3d54b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SpaceToDepth.pbtxt
@@ -0,0 +1,95 @@
+op {
+  graph_op_name: "SpaceToDepth"
+  attr {
+    name: "block_size"
+    description: <<END
+The size of the spatial block.
+END
+  }
+  summary: "SpaceToDepth for tensors of type T."
+  description: <<END
+Rearranges blocks of spatial data, into depth. More specifically,
+this op outputs a copy of the input tensor where values from the `height`
+and `width` dimensions are moved to the `depth` dimension.
+The attr `block_size` indicates the input block size.
+
+  * Non-overlapping blocks of size `block_size x block size` are rearranged
+    into depth at each location.
+  * The depth of the output tensor is `block_size * block_size * input_depth`.
+  * The Y, X coordinates within each block of the input become the high order
+    component of the output channel index.
+  * The input tensor's height and width must be divisible by block_size.
+
+The `data_format` attr specifies the layout of the input and output tensors
+with the following options:
+  "NHWC": `[ batch, height, width, channels ]`
+  "NCHW": `[ batch, channels, height, width ]`
+  "NCHW_VECT_C":
+      `qint8 [ batch, channels / 4, height, width, channels % 4 ]`
+
+It is useful to consider the operation as transforming a 6-D Tensor.
+e.g. for data_format = NHWC,
+     Each element in the input tensor can be specified via 6 coordinates,
+     ordered by decreasing memory layout significance as:
+     n,oY,bY,oX,bX,iC  (where n=batch index, oX, oY means X or Y coordinates
+                        within the output image, bX, bY means coordinates
+                        within the input block, iC means input channels).
+     The output would be a transpose to the following layout:
+     n,oY,oX,bY,bX,iC
+
+This operation is useful for resizing the activations between convolutions
+(but keeping all data), e.g. instead of pooling. It is also useful for training
+purely convolutional models.
+
+For example, given an input of shape `[1, 2, 2, 1]`, data_format = "NHWC" and
+block_size = 2:
+
+```
+x = [[[[1], [2]],
+      [[3], [4]]]]
+```
+
+This operation will output a tensor of shape `[1, 1, 1, 4]`:
+
+```
+[[[[1, 2, 3, 4]]]]
+```
+
+Here, the input has a batch of 1 and each batch element has shape `[2, 2, 1]`,
+the corresponding output will have a single element (i.e. width and height are
+both 1) and will have a depth of 4 channels (1 * block_size * block_size).
+The output element shape is `[1, 1, 4]`.
+
+For an input tensor with larger depth, here of shape `[1, 2, 2, 3]`, e.g.
+
+```
+x = [[[[1, 2, 3], [4, 5, 6]],
+      [[7, 8, 9], [10, 11, 12]]]]
+```
+
+This operation, for block_size of 2, will return the following tensor of shape
+`[1, 1, 1, 12]`
+
+```
+[[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
+```
+
+Similarly, for the following input of shape `[1 4 4 1]`, and a block size of 2:
+
+```
+x = [[[[1],   [2],  [5],  [6]],
+      [[3],   [4],  [7],  [8]],
+      [[9],  [10], [13],  [14]],
+      [[11], [12], [15],  [16]]]]
+```
+
+the operator will return the following tensor of shape `[1 2 2 4]`:
+
+```
+x = [[[[1, 2, 3, 4],
+       [5, 6, 7, 8]],
+      [[9, 10, 11, 12],
+       [13, 14, 15, 16]]]]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseAccumulatorApplyGradient.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseAccumulatorApplyGradient.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..11c49805879a443375391a883acf9a0e88fa0692
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseAccumulatorApplyGradient.pbtxt
@@ -0,0 +1,55 @@
+op {
+  graph_op_name: "SparseAccumulatorApplyGradient"
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a accumulator.
+END
+  }
+  in_arg {
+    name: "local_step"
+    description: <<END
+The local_step value at which the sparse gradient was computed.
+END
+  }
+  in_arg {
+    name: "gradient_indices"
+    description: <<END
+Indices of the sparse gradient to be accumulated. Must be a
+vector.
+END
+  }
+  in_arg {
+    name: "gradient_values"
+    description: <<END
+Values are the non-zero slices of the gradient, and must have
+the same first dimension as indices, i.e., the nnz represented by indices and
+values must be consistent.
+END
+  }
+  in_arg {
+    name: "gradient_shape"
+    description: <<END
+Shape of the sparse gradient to be accumulated.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The data type of accumulated gradients. Needs to correspond to the type
+of the accumulator.
+END
+  }
+  attr {
+    name: "has_known_shape"
+    description: <<END
+Boolean indicating whether gradient_shape is unknown, in which
+case the input is ignored during validation.
+END
+  }
+  summary: "Applies a sparse gradient to a given accumulator."
+  description: <<END
+Does not add if local_step is smaller than the accumulator's
+global_step.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseAccumulatorTakeGradient.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseAccumulatorTakeGradient.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..725bbaf5018ca960fd5b544eb5199975311e2246
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseAccumulatorTakeGradient.pbtxt
@@ -0,0 +1,49 @@
+op {
+  graph_op_name: "SparseAccumulatorTakeGradient"
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a SparseConditionalAccumulator.
+END
+  }
+  in_arg {
+    name: "num_required"
+    description: <<END
+Number of gradients required before we return an aggregate.
+END
+  }
+  out_arg {
+    name: "indices"
+    description: <<END
+Indices of the average of the accumulated sparse gradients.
+END
+  }
+  out_arg {
+    name: "values"
+    description: <<END
+Values of the average of the accumulated sparse gradients.
+END
+  }
+  out_arg {
+    name: "shape"
+    description: <<END
+Shape of the average of the accumulated sparse gradients.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The data type of accumulated gradients. Needs to correspond to the type
+of the accumulator.
+END
+  }
+  summary: "Extracts the average sparse gradient in a SparseConditionalAccumulator."
+  description: <<END
+The op will blocks until sufficient (i.e., more than num_required)
+gradients have been accumulated. If the accumulator has already
+aggregated more than num_required gradients, it will return its
+average of the accumulated gradients.  Also automatically increments
+the recorded global_step in the accumulator by 1, and resets the
+aggregate to 0.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseAdd.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseAdd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d2409aa3b2fb5c9fb450d7479a78449f33517db1
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseAdd.pbtxt
@@ -0,0 +1,62 @@
+op {
+  graph_op_name: "SparseAdd"
+  in_arg {
+    name: "a_indices"
+    description: <<END
+2-D.  The `indices` of the first `SparseTensor`, size `[nnz, ndims]` Matrix.
+END
+  }
+  in_arg {
+    name: "a_values"
+    description: <<END
+1-D.  The `values` of the first `SparseTensor`, size `[nnz]` Vector.
+END
+  }
+  in_arg {
+    name: "a_shape"
+    description: <<END
+1-D.  The `shape` of the first `SparseTensor`, size `[ndims]` Vector.
+END
+  }
+  in_arg {
+    name: "b_indices"
+    description: <<END
+2-D.  The `indices` of the second `SparseTensor`, size `[nnz, ndims]` Matrix.
+END
+  }
+  in_arg {
+    name: "b_values"
+    description: <<END
+1-D.  The `values` of the second `SparseTensor`, size `[nnz]` Vector.
+END
+  }
+  in_arg {
+    name: "b_shape"
+    description: <<END
+1-D.  The `shape` of the second `SparseTensor`, size `[ndims]` Vector.
+END
+  }
+  in_arg {
+    name: "thresh"
+    description: <<END
+0-D.  The magnitude threshold that determines if an output value/index
+pair takes space.
+END
+  }
+  summary: "Adds two `SparseTensor` objects to produce another `SparseTensor`."
+  description: <<END
+The input `SparseTensor` objects' indices are assumed ordered in standard
+lexicographic order.  If this is not the case, before this step run
+`SparseReorder` to restore index ordering.
+
+By default, if two values sum to zero at some index, the output `SparseTensor`
+would still include that particular location in its index, storing a zero in the
+corresponding value slot.  To override this, callers can specify `thresh`,
+indicating that if the sum has a magnitude strictly smaller than `thresh`, its
+corresponding value and index would then not be included.  In particular,
+`thresh == 0` (default) means everything is kept and actual thresholding happens
+only for a positive value.
+
+In the following shapes, `nnz` is the count after taking `thresh` into account.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseAddGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseAddGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e5e0a7d9cbc45f0bd3f617614a2397f7db563c64
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseAddGrad.pbtxt
@@ -0,0 +1,50 @@
+op {
+  graph_op_name: "SparseAddGrad"
+  in_arg {
+    name: "backprop_val_grad"
+    description: <<END
+1-D with shape `[nnz(sum)]`.  The gradient with respect to
+the non-empty values of the sum.
+END
+  }
+  in_arg {
+    name: "a_indices"
+    description: <<END
+2-D.  The `indices` of the `SparseTensor` A, size `[nnz(A), ndims]`.
+END
+  }
+  in_arg {
+    name: "b_indices"
+    description: <<END
+2-D.  The `indices` of the `SparseTensor` B, size `[nnz(B), ndims]`.
+END
+  }
+  in_arg {
+    name: "sum_indices"
+    description: <<END
+2-D.  The `indices` of the sum `SparseTensor`, size
+`[nnz(sum), ndims]`.
+END
+  }
+  out_arg {
+    name: "a_val_grad"
+    description: <<END
+1-D with shape `[nnz(A)]`. The gradient with respect to the
+non-empty values of A.
+END
+  }
+  out_arg {
+    name: "b_val_grad"
+    description: <<END
+1-D with shape `[nnz(B)]`. The gradient with respect to the
+non-empty values of B.
+END
+  }
+  summary: "The gradient operator for the SparseAdd op."
+  description: <<END
+The SparseAdd op calculates A + B, where A, B, and the sum are all represented
+as `SparseTensor` objects.  This op takes in the upstream gradient w.r.t.
+non-empty values of the sum, and outputs the gradients w.r.t. the non-empty
+values of A and B.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseApplyAdadelta.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseApplyAdadelta.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..15c1797d2dd6cde13b87463c74e42525bc3dd741
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseApplyAdadelta.pbtxt
@@ -0,0 +1,59 @@
+op {
+  graph_op_name: "SparseApplyAdadelta"
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum_update"
+    description: <<END
+: Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Learning rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "rho"
+    description: <<END
+Decay factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "epsilon"
+    description: <<END
+Constant factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var and accum.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, updating of the var and accum tensors will be protected by
+a lock; otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "var: Should be from a Variable()."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseApplyAdagrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseApplyAdagrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1698e2def0766f01a49671be7927374c033199e4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseApplyAdagrad.pbtxt
@@ -0,0 +1,53 @@
+op {
+  graph_op_name: "SparseApplyAdagrad"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Learning rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var and accum.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var and accum tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update relevant entries in \'*var\' and \'*accum\' according to the adagrad scheme."
+  description: <<END
+That is for rows we have grad for, we update var and accum as follows:
+accum += grad * grad
+var -= lr * grad * (1 / sqrt(accum))
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseApplyAdagradDA.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseApplyAdagradDA.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a6878eb70b3f21111cee24fac0d11170df051cf6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseApplyAdagradDA.pbtxt
@@ -0,0 +1,71 @@
+op {
+  graph_op_name: "SparseApplyAdagradDA"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "gradient_accumulator"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "gradient_squared_accumulator"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var and accum.
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Learning rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "global_step"
+    description: <<END
+Training step number. Must be a scalar.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, updating of the var and accum tensors will be protected by
+a lock; otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Update entries in \'*var\' and \'*accum\' according to the proximal adagrad scheme."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseApplyCenteredRMSProp.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseApplyCenteredRMSProp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2c6a36bf456e84cc855ae64fbc5a27e1ac234736
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseApplyCenteredRMSProp.pbtxt
@@ -0,0 +1,90 @@
+op {
+  graph_op_name: "SparseApplyCenteredRMSProp"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "mg"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "ms"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "mom"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "rho"
+    description: <<END
+Decay rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "epsilon"
+    description: <<END
+Ridge term. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var, ms and mom.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var, mg, ms, and mom tensors is
+protected by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update \'*var\' according to the centered RMSProp algorithm."
+  description: <<END
+The centered RMSProp algorithm uses an estimate of the centered second moment
+(i.e., the variance) for normalization, as opposed to regular RMSProp, which
+uses the (uncentered) second moment. This often helps with training, but is
+slightly more expensive in terms of computation and memory.
+
+Note that in dense implementation of this algorithm, mg, ms, and mom will
+update even if the grad is zero, but in this sparse implementation, mg, ms,
+and mom will not update in iterations during which the grad is zero.
+
+mean_square = decay * mean_square + (1-decay) * gradient ** 2
+mean_grad = decay * mean_grad + (1-decay) * gradient
+Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2)
+
+ms <- rho * ms_{t-1} + (1-rho) * grad * grad
+mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
+var <- var - mom
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseApplyFtrl.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseApplyFtrl.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..524b5c5a47dd6570d7cb7b59775babcdd2b1d19d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseApplyFtrl.pbtxt
@@ -0,0 +1,80 @@
+op {
+  graph_op_name: "SparseApplyFtrl"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "linear"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var and accum.
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "lr_power"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var and accum tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update relevant entries in \'*var\' according to the Ftrl-proximal scheme."
+  description: <<END
+That is for rows we have grad for, we update var, accum and linear as follows:
+accum_new = accum + grad * grad
+linear += grad + (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
+quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
+var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
+accum = accum_new
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseApplyFtrlV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseApplyFtrlV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9247fb61b882ad3fabf7622d91f5c1574b00f656
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseApplyFtrlV2.pbtxt
@@ -0,0 +1,82 @@
+op {
+  graph_op_name: "SparseApplyFtrlV2"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "linear"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var and accum.
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 shrinkage regulariation. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "lr_power"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var and accum tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update relevant entries in \'*var\' according to the Ftrl-proximal scheme."
+  description: <<END
+That is for rows we have grad for, we update var, accum and linear as follows:
+grad_with_shrinkage = grad + 2 * l2_shrinkage * var
+accum_new = accum + grad_with_shrinkage * grad_with_shrinkage
+linear += grad_with_shrinkage +
+    (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
+quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
+var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
+accum = accum_new
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseApplyMomentum.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseApplyMomentum.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8d9ac9ea3fa46a2d19a7f4d8967a0acd17f00333
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseApplyMomentum.pbtxt
@@ -0,0 +1,70 @@
+op {
+  graph_op_name: "SparseApplyMomentum"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Learning rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var and accum.
+END
+  }
+  in_arg {
+    name: "momentum"
+    description: <<END
+Momentum. Must be a scalar.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var and accum tensors will be protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  attr {
+    name: "use_nesterov"
+    description: <<END
+If `True`, the tensor passed to compute grad will be
+var - lr * momentum * accum, so in the end, the var you get is actually
+var - lr * momentum * accum.
+END
+  }
+  summary: "Update relevant entries in \'*var\' and \'*accum\' according to the momentum scheme."
+  description: <<END
+Set use_nesterov = True if you want to use Nesterov momentum.
+
+That is for rows we have grad for, we update var and accum as follows:
+
+accum = accum * momentum + grad
+var -= lr * accum
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseApplyProximalAdagrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseApplyProximalAdagrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..80541b91c7ed01183596de26881956aa90c14b17
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseApplyProximalAdagrad.pbtxt
@@ -0,0 +1,66 @@
+op {
+  graph_op_name: "SparseApplyProximalAdagrad"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "accum"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Learning rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var and accum.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, updating of the var and accum tensors will be protected by
+a lock; otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Sparse update entries in \'*var\' and \'*accum\' according to FOBOS algorithm."
+  description: <<END
+That is for rows we have grad for, we update var and accum as follows:
+accum += grad * grad
+prox_v = var
+prox_v -= lr * grad * (1 / sqrt(accum))
+var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseApplyProximalGradientDescent.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseApplyProximalGradientDescent.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5200e5516df10ca438828cb38fa1db8adba156b0
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseApplyProximalGradientDescent.pbtxt
@@ -0,0 +1,58 @@
+op {
+  graph_op_name: "SparseApplyProximalGradientDescent"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "alpha"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l1"
+    description: <<END
+L1 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "l2"
+    description: <<END
+L2 regularization. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var and accum.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If True, the subtraction will be protected by a lock;
+otherwise the behavior is undefined, but may exhibit less contention.
+END
+  }
+  summary: "Sparse update \'*var\' as FOBOS algorithm with fixed learning rate."
+  description: <<END
+That is for rows we have grad for, we update var as follows:
+prox_v = var - alpha * grad
+var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseApplyRMSProp.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseApplyRMSProp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a4dbd608b893b334cba07ea0713a45fa4125f102
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseApplyRMSProp.pbtxt
@@ -0,0 +1,78 @@
+op {
+  graph_op_name: "SparseApplyRMSProp"
+  in_arg {
+    name: "var"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "ms"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "mom"
+    description: <<END
+Should be from a Variable().
+END
+  }
+  in_arg {
+    name: "lr"
+    description: <<END
+Scaling factor. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "rho"
+    description: <<END
+Decay rate. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "epsilon"
+    description: <<END
+Ridge term. Must be a scalar.
+END
+  }
+  in_arg {
+    name: "grad"
+    description: <<END
+The gradient.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+A vector of indices into the first dimension of var, ms and mom.
+END
+  }
+  out_arg {
+    name: "out"
+    description: <<END
+Same as "var".
+END
+  }
+  attr {
+    name: "use_locking"
+    description: <<END
+If `True`, updating of the var, ms, and mom tensors is protected
+by a lock; otherwise the behavior is undefined, but may exhibit less
+contention.
+END
+  }
+  summary: "Update \'*var\' according to the RMSProp algorithm."
+  description: <<END
+Note that in dense implementation of this algorithm, ms and mom will
+update even if the grad is zero, but in this sparse implementation, ms
+and mom will not update in iterations during which the grad is zero.
+
+mean_square = decay * mean_square + (1-decay) * gradient ** 2
+Delta = learning_rate * gradient / sqrt(mean_square + epsilon)
+
+ms <- rho * ms_{t-1} + (1-rho) * grad * grad
+mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
+var <- var - mom
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseConcat.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseConcat.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a72ae904755b97a5516c3467fc3519391e0df579
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseConcat.pbtxt
@@ -0,0 +1,90 @@
+op {
+  graph_op_name: "SparseConcat"
+  in_arg {
+    name: "indices"
+    description: <<END
+2-D.  Indices of each input `SparseTensor`.
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+1-D.  Non-empty values of each `SparseTensor`.
+END
+  }
+  in_arg {
+    name: "shapes"
+    description: <<END
+1-D.  Shapes of each `SparseTensor`.
+END
+  }
+  out_arg {
+    name: "output_indices"
+    description: <<END
+2-D.  Indices of the concatenated `SparseTensor`.
+END
+  }
+  out_arg {
+    name: "output_values"
+    description: <<END
+1-D.  Non-empty values of the concatenated `SparseTensor`.
+END
+  }
+  out_arg {
+    name: "output_shape"
+    description: <<END
+1-D.  Shape of the concatenated `SparseTensor`.
+END
+  }
+  attr {
+    name: "concat_dim"
+    description: <<END
+Dimension to concatenate along. Must be in range [-rank, rank),
+where rank is the number of dimensions in each input `SparseTensor`.
+END
+  }
+  summary: "Concatenates a list of `SparseTensor` along the specified dimension."
+  description: <<END
+Concatenation is with respect to the dense versions of these sparse tensors.
+It is assumed that each input is a `SparseTensor` whose elements are ordered
+along increasing dimension number.
+
+All inputs' shapes must match, except for the concat dimension.  The
+`indices`, `values`, and `shapes` lists must have the same length.
+
+The output shape is identical to the inputs', except along the concat
+dimension, where it is the sum of the inputs' sizes along that dimension.
+
+The output elements will be resorted to preserve the sort order along
+increasing dimension number.
+
+This op runs in `O(M log M)` time, where `M` is the total number of non-empty
+values across all inputs. This is due to the need for an internal sort in
+order to concatenate efficiently across an arbitrary dimension.
+
+For example, if `concat_dim = 1` and the inputs are
+
+    sp_inputs[0]: shape = [2, 3]
+    [0, 2]: "a"
+    [1, 0]: "b"
+    [1, 1]: "c"
+
+    sp_inputs[1]: shape = [2, 4]
+    [0, 1]: "d"
+    [0, 2]: "e"
+
+then the output will be
+
+    shape = [2, 7]
+    [0, 2]: "a"
+    [0, 4]: "d"
+    [0, 5]: "e"
+    [1, 0]: "b"
+    [1, 1]: "c"
+
+Graphically this is equivalent to doing
+
+    [    a] concat [  d e  ] = [    a   d e  ]
+    [b c  ]        [       ]   [b c          ]
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseConditionalAccumulator.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseConditionalAccumulator.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c367416f2aa0045d837a489af68623e1fcea0a34
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseConditionalAccumulator.pbtxt
@@ -0,0 +1,44 @@
+op {
+  graph_op_name: "SparseConditionalAccumulator"
+  out_arg {
+    name: "handle"
+    description: <<END
+The handle to the accumulator.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of the value being accumulated.
+END
+  }
+  attr {
+    name: "shape"
+    description: <<END
+The shape of the values.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this accumulator is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this accumulator will be shared under the given name
+across multiple sessions.
+END
+  }
+  summary: "A conditional accumulator for aggregating sparse gradients."
+  description: <<END
+The accumulator accepts gradients marked with local_step greater or
+equal to the most recent global_step known to the accumulator. The
+average can be extracted from the accumulator, provided sufficient
+gradients have been accumulated. Extracting the average automatically
+resets the aggregate to 0, and increments the global_step recorded by
+the accumulator.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseCross.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseCross.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2aea6cfe4fddd274e7d1f5822d9e35badd042dfd
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseCross.pbtxt
@@ -0,0 +1,106 @@
+op {
+  graph_op_name: "SparseCross"
+  in_arg {
+    name: "indices"
+    description: <<END
+2-D.  Indices of each input `SparseTensor`.
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+1-D.   values of each `SparseTensor`.
+END
+  }
+  in_arg {
+    name: "shapes"
+    description: <<END
+1-D.   Shapes of each `SparseTensor`.
+END
+  }
+  in_arg {
+    name: "dense_inputs"
+    description: <<END
+2-D.    Columns represented by dense `Tensor`.
+END
+  }
+  out_arg {
+    name: "output_indices"
+    description: <<END
+2-D.  Indices of the concatenated `SparseTensor`.
+END
+  }
+  out_arg {
+    name: "output_values"
+    description: <<END
+1-D.  Non-empty values of the concatenated or hashed
+`SparseTensor`.
+END
+  }
+  out_arg {
+    name: "output_shape"
+    description: <<END
+1-D.  Shape of the concatenated `SparseTensor`.
+END
+  }
+  attr {
+    name: "hashed_output"
+    description: <<END
+If true, returns the hash of the cross instead of the string.
+This will allow us avoiding string manipulations.
+END
+  }
+  attr {
+    name: "num_buckets"
+    description: <<END
+It is used if hashed_output is true.
+output = hashed_value%num_buckets if num_buckets > 0 else hashed_value.
+END
+  }
+  attr {
+    name: "hash_key"
+    description: <<END
+Specify the hash_key that will be used by the `FingerprintCat64`
+function to combine the crosses fingerprints.
+END
+  }
+  summary: "Generates sparse cross from a list of sparse and dense tensors."
+  description: <<END
+The op takes two lists, one of 2D `SparseTensor` and one of 2D `Tensor`, each
+representing features of one feature column. It outputs a 2D `SparseTensor` with
+the batchwise crosses of these features.
+
+For example, if the inputs are
+
+    inputs[0]: SparseTensor with shape = [2, 2]
+    [0, 0]: "a"
+    [1, 0]: "b"
+    [1, 1]: "c"
+
+    inputs[1]: SparseTensor with shape = [2, 1]
+    [0, 0]: "d"
+    [1, 0]: "e"
+
+    inputs[2]: Tensor [["f"], ["g"]]
+
+then the output will be
+
+    shape = [2, 2]
+    [0, 0]: "a_X_d_X_f"
+    [1, 0]: "b_X_e_X_g"
+    [1, 1]: "c_X_e_X_g"
+
+if hashed_output=true then the output will be
+
+    shape = [2, 2]
+    [0, 0]: FingerprintCat64(
+                Fingerprint64("f"), FingerprintCat64(
+                    Fingerprint64("d"), Fingerprint64("a")))
+    [1, 0]: FingerprintCat64(
+                Fingerprint64("g"), FingerprintCat64(
+                    Fingerprint64("e"), Fingerprint64("b")))
+    [1, 1]: FingerprintCat64(
+                Fingerprint64("g"), FingerprintCat64(
+                    Fingerprint64("e"), Fingerprint64("c")))
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseDenseCwiseAdd.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseDenseCwiseAdd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..81d346adfbf77435490b708f5eaacdc8bd701b4e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseDenseCwiseAdd.pbtxt
@@ -0,0 +1,45 @@
+op {
+  graph_op_name: "SparseDenseCwiseAdd"
+  in_arg {
+    name: "sp_indices"
+    description: <<END
+2-D.  `N x R` matrix with the indices of non-empty values in a
+SparseTensor, possibly not in canonical ordering.
+END
+  }
+  in_arg {
+    name: "sp_values"
+    description: <<END
+1-D.  `N` non-empty values corresponding to `sp_indices`.
+END
+  }
+  in_arg {
+    name: "sp_shape"
+    description: <<END
+1-D.  Shape of the input SparseTensor.
+END
+  }
+  in_arg {
+    name: "dense"
+    description: <<END
+`R`-D.  The dense Tensor operand.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+1-D.  The `N` values that are operated on.
+END
+  }
+  summary: "Adds up a SparseTensor and a dense Tensor, using these special rules:"
+  description: <<END
+(1) Broadcasts the dense side to have the same shape as the sparse side, if
+    eligible;
+(2) Then, only the dense values pointed to by the indices of the SparseTensor
+    participate in the cwise addition.
+
+By these rules, the result is a logical SparseTensor with exactly the same
+indices and shape, but possibly with different non-zero values.  The output of
+this Op is the resultant non-zero values.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseDenseCwiseDiv.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseDenseCwiseDiv.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..40ea9c846afe216b07f64de01c30ee722b620def
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseDenseCwiseDiv.pbtxt
@@ -0,0 +1,39 @@
+op {
+  graph_op_name: "SparseDenseCwiseDiv"
+  in_arg {
+    name: "sp_indices"
+    description: <<END
+2-D.  `N x R` matrix with the indices of non-empty values in a
+SparseTensor, possibly not in canonical ordering.
+END
+  }
+  in_arg {
+    name: "sp_values"
+    description: <<END
+1-D.  `N` non-empty values corresponding to `sp_indices`.
+END
+  }
+  in_arg {
+    name: "sp_shape"
+    description: <<END
+1-D.  Shape of the input SparseTensor.
+END
+  }
+  in_arg {
+    name: "dense"
+    description: <<END
+`R`-D.  The dense Tensor operand.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+1-D.  The `N` values that are operated on.
+END
+  }
+  summary: "Component-wise divides a SparseTensor by a dense Tensor."
+  description: <<END
+*Limitation*: this Op only broadcasts the dense side to the sparse side, but not
+the other direction.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseDenseCwiseMul.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseDenseCwiseMul.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..262ab2dc76fa50750a117f717ea090616d4450ee
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseDenseCwiseMul.pbtxt
@@ -0,0 +1,43 @@
+op {
+  graph_op_name: "SparseDenseCwiseMul"
+  in_arg {
+    name: "sp_indices"
+    description: <<END
+2-D.  `N x R` matrix with the indices of non-empty values in a
+SparseTensor, possibly not in canonical ordering.
+END
+  }
+  in_arg {
+    name: "sp_values"
+    description: <<END
+1-D.  `N` non-empty values corresponding to `sp_indices`.
+END
+  }
+  in_arg {
+    name: "sp_shape"
+    description: <<END
+1-D.  Shape of the input SparseTensor.
+END
+  }
+  in_arg {
+    name: "dense"
+    description: <<END
+`R`-D.  The dense Tensor operand.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+1-D.  The `N` values that are operated on.
+END
+  }
+  summary: "Component-wise multiplies a SparseTensor by a dense Tensor."
+  description: <<END
+The output locations corresponding to the implicitly zero elements in the sparse
+tensor will be zero (i.e., will not take up storage space), regardless of the
+contents of the dense tensor (even if it's +/-INF and that INF*0 == NaN).
+
+*Limitation*: this Op only broadcasts the dense side to the sparse side, but not
+the other direction.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseFillEmptyRows.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseFillEmptyRows.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f9f25554b221c25cca7db7b8f9613c00b55682dd
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseFillEmptyRows.pbtxt
@@ -0,0 +1,87 @@
+op {
+  graph_op_name: "SparseFillEmptyRows"
+  in_arg {
+    name: "indices"
+    description: <<END
+2-D. the indices of the sparse tensor.
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+1-D. the values of the sparse tensor.
+END
+  }
+  in_arg {
+    name: "dense_shape"
+    description: <<END
+1-D. the shape of the sparse tensor.
+END
+  }
+  in_arg {
+    name: "default_value"
+    description: <<END
+0-D. default value to insert into location `[row, 0, ..., 0]`
+  for rows missing from the input sparse tensor.
+output indices: 2-D. the indices of the filled sparse tensor.
+END
+  }
+  out_arg {
+    name: "output_values"
+    description: <<END
+1-D. the values of the filled sparse tensor.
+END
+  }
+  out_arg {
+    name: "empty_row_indicator"
+    description: <<END
+1-D. whether the dense row was missing in the
+input sparse tensor.
+END
+  }
+  out_arg {
+    name: "reverse_index_map"
+    description: <<END
+1-D. a map from the input indices to the output indices.
+END
+  }
+  summary: "Fills empty rows in the input 2-D `SparseTensor` with a default value."
+  description: <<END
+The input `SparseTensor` is represented via the tuple of inputs
+(`indices`, `values`, `dense_shape`).  The output `SparseTensor` has the
+same `dense_shape` but with indices `output_indices` and values
+`output_values`.
+
+This op inserts a single entry for every row that doesn't have any values.
+The index is created as `[row, 0, ..., 0]` and the inserted value
+is `default_value`.
+
+For example, suppose `sp_input` has shape `[5, 6]` and non-empty values:
+
+    [0, 1]: a
+    [0, 3]: b
+    [2, 0]: c
+    [3, 1]: d
+
+Rows 1 and 4 are empty, so the output will be of shape `[5, 6]` with values:
+
+    [0, 1]: a
+    [0, 3]: b
+    [1, 0]: default_value
+    [2, 0]: c
+    [3, 1]: d
+    [4, 0]: default_value
+
+The output `SparseTensor` will be in row-major order and will have the
+same shape as the input.
+
+This op also returns an indicator vector shaped `[dense_shape[0]]` such that
+
+    empty_row_indicator[i] = True iff row i was an empty row.
+
+And a reverse index map vector shaped `[indices.shape[0]]` that is used during
+backpropagation,
+
+    reverse_index_map[j] = out_j s.t. indices[j, :] == output_indices[out_j, :]
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseFillEmptyRowsGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseFillEmptyRowsGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..eef43e61f2c8aa3263a524fa00cf89550924d404
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseFillEmptyRowsGrad.pbtxt
@@ -0,0 +1,38 @@
+op {
+  graph_op_name: "SparseFillEmptyRowsGrad"
+  in_arg {
+    name: "reverse_index_map"
+    description: <<END
+1-D.  The reverse index map from SparseFillEmptyRows.
+END
+  }
+  in_arg {
+    name: "grad_values"
+    description: <<END
+1-D.  The gradients from backprop.
+END
+  }
+  out_arg {
+    name: "d_values"
+    description: <<END
+1-D.  The backprop into values.
+END
+  }
+  out_arg {
+    name: "d_default_value"
+    description: <<END
+0-D.  The backprop into default_value.
+END
+  }
+  summary: "The gradient of SparseFillEmptyRows."
+  description: <<END
+Takes vectors reverse_index_map, shaped `[N]`, and grad_values,
+shaped `[N_full]`, where `N_full >= N` and copies data into either
+`d_values` or `d_default_value`.  Here `d_values` is shaped `[N]` and
+`d_default_value` is a scalar.
+
+  d_values[j] = grad_values[reverse_index_map[j]]
+  d_default_value = sum_{k : 0 .. N_full - 1} (
+     grad_values[k] * 1{k not in reverse_index_map})
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseMatMul.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseMatMul.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..58f2ede62984073d5944226f4b58bc95818b3f32
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseMatMul.pbtxt
@@ -0,0 +1,13 @@
+op {
+  graph_op_name: "SparseMatMul"
+  summary: "Multiply matrix \"a\" by matrix \"b\"."
+  description: <<END
+The inputs must be two-dimensional matrices and the inner dimension of "a" must
+match the outer dimension of "b". This op is optimized for the case where at
+least one of "a" or "b" is sparse. The breakeven for using this versus a dense
+matrix multiply on one platform was 30% zero values in the sparse matrix.
+
+The gradient computation of this operation will only take advantage of sparsity
+in the input gradient when that gradient comes from a Relu.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseReduceMax.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseReduceMax.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2c2e7e0df176efbc9ca997d271f3c8c08c6c01f3
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseReduceMax.pbtxt
@@ -0,0 +1,55 @@
+op {
+  graph_op_name: "SparseReduceMax"
+  in_arg {
+    name: "input_indices"
+    description: <<END
+2-D.  `N x R` matrix with the indices of non-empty values in a
+SparseTensor, possibly not in canonical ordering.
+END
+  }
+  in_arg {
+    name: "input_values"
+    description: <<END
+1-D.  `N` non-empty values corresponding to `input_indices`.
+END
+  }
+  in_arg {
+    name: "input_shape"
+    description: <<END
+1-D.  Shape of the input SparseTensor.
+END
+  }
+  in_arg {
+    name: "reduction_axes"
+    description: <<END
+1-D.  Length-`K` vector containing the reduction axes.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+`R-K`-D.  The reduced Tensor.
+END
+  }
+  attr {
+    name: "keep_dims"
+    description: <<END
+If true, retain reduced dimensions with length 1.
+END
+  }
+  summary: "Computes the max of elements across dimensions of a SparseTensor."
+  description: <<END
+This Op takes a SparseTensor and is the sparse counterpart to
+`tf.reduce_max()`.  In particular, this Op also returns a dense `Tensor`
+instead of a sparse one.
+
+Reduces `sp_input` along the dimensions given in `reduction_axes`.  Unless
+`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+`reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
+with length 1.
+
+If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
+with a single element is returned.  Additionally, the axes can be negative,
+which are interpreted according to the indexing rules in Python.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseReduceMaxSparse.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseReduceMaxSparse.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c75a2bb233a6f351ff00f156bd92c67b668b77a6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseReduceMaxSparse.pbtxt
@@ -0,0 +1,49 @@
+op {
+  graph_op_name: "SparseReduceMaxSparse"
+  in_arg {
+    name: "input_indices"
+    description: <<END
+2-D.  `N x R` matrix with the indices of non-empty values in a
+SparseTensor, possibly not in canonical ordering.
+END
+  }
+  in_arg {
+    name: "input_values"
+    description: <<END
+1-D.  `N` non-empty values corresponding to `input_indices`.
+END
+  }
+  in_arg {
+    name: "input_shape"
+    description: <<END
+1-D.  Shape of the input SparseTensor.
+END
+  }
+  in_arg {
+    name: "reduction_axes"
+    description: <<END
+1-D.  Length-`K` vector containing the reduction axes.
+END
+  }
+  attr {
+    name: "keep_dims"
+    description: <<END
+If true, retain reduced dimensions with length 1.
+END
+  }
+  summary: "Computes the max of elements across dimensions of a SparseTensor."
+  description: <<END
+This Op takes a SparseTensor and is the sparse counterpart to
+`tf.reduce_max()`.  In contrast to SparseReduceMax, this Op returns a
+SparseTensor.
+
+Reduces `sp_input` along the dimensions given in `reduction_axes`.  Unless
+`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+`reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
+with length 1.
+
+If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
+with a single element is returned.  Additionally, the axes can be negative,
+which are interpreted according to the indexing rules in Python.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseReduceSum.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseReduceSum.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cf6f868d1481bde17c0bda8a9bdabe19cce6e632
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseReduceSum.pbtxt
@@ -0,0 +1,55 @@
+op {
+  graph_op_name: "SparseReduceSum"
+  in_arg {
+    name: "input_indices"
+    description: <<END
+2-D.  `N x R` matrix with the indices of non-empty values in a
+SparseTensor, possibly not in canonical ordering.
+END
+  }
+  in_arg {
+    name: "input_values"
+    description: <<END
+1-D.  `N` non-empty values corresponding to `input_indices`.
+END
+  }
+  in_arg {
+    name: "input_shape"
+    description: <<END
+1-D.  Shape of the input SparseTensor.
+END
+  }
+  in_arg {
+    name: "reduction_axes"
+    description: <<END
+1-D.  Length-`K` vector containing the reduction axes.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+`R-K`-D.  The reduced Tensor.
+END
+  }
+  attr {
+    name: "keep_dims"
+    description: <<END
+If true, retain reduced dimensions with length 1.
+END
+  }
+  summary: "Computes the sum of elements across dimensions of a SparseTensor."
+  description: <<END
+This Op takes a SparseTensor and is the sparse counterpart to
+`tf.reduce_sum()`.  In particular, this Op also returns a dense `Tensor`
+instead of a sparse one.
+
+Reduces `sp_input` along the dimensions given in `reduction_axes`.  Unless
+`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+`reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
+with length 1.
+
+If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
+with a single element is returned.  Additionally, the axes can be negative,
+which are interpreted according to the indexing rules in Python.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseReduceSumSparse.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseReduceSumSparse.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cad169e5f9d7f7d6c00583ad34b5dd915eb8a111
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseReduceSumSparse.pbtxt
@@ -0,0 +1,49 @@
+op {
+  graph_op_name: "SparseReduceSumSparse"
+  in_arg {
+    name: "input_indices"
+    description: <<END
+2-D.  `N x R` matrix with the indices of non-empty values in a
+SparseTensor, possibly not in canonical ordering.
+END
+  }
+  in_arg {
+    name: "input_values"
+    description: <<END
+1-D.  `N` non-empty values corresponding to `input_indices`.
+END
+  }
+  in_arg {
+    name: "input_shape"
+    description: <<END
+1-D.  Shape of the input SparseTensor.
+END
+  }
+  in_arg {
+    name: "reduction_axes"
+    description: <<END
+1-D.  Length-`K` vector containing the reduction axes.
+END
+  }
+  attr {
+    name: "keep_dims"
+    description: <<END
+If true, retain reduced dimensions with length 1.
+END
+  }
+  summary: "Computes the sum of elements across dimensions of a SparseTensor."
+  description: <<END
+This Op takes a SparseTensor and is the sparse counterpart to
+`tf.reduce_sum()`.  In contrast to SparseReduceSum, this Op returns a
+SparseTensor.
+
+Reduces `sp_input` along the dimensions given in `reduction_axes`.  Unless
+`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+`reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
+with length 1.
+
+If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
+with a single element is returned.  Additionally, the axes can be negative,
+which are interpreted according to the indexing rules in Python.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseReorder.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseReorder.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..07ffc6dcf33c3a725c45c124cd79e94e11af91c6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseReorder.pbtxt
@@ -0,0 +1,46 @@
+op {
+  graph_op_name: "SparseReorder"
+  in_arg {
+    name: "input_indices"
+    description: <<END
+2-D.  `N x R` matrix with the indices of non-empty values in a
+SparseTensor, possibly not in canonical ordering.
+END
+  }
+  in_arg {
+    name: "input_values"
+    description: <<END
+1-D.  `N` non-empty values corresponding to `input_indices`.
+END
+  }
+  in_arg {
+    name: "input_shape"
+    description: <<END
+1-D.  Shape of the input SparseTensor.
+END
+  }
+  out_arg {
+    name: "output_indices"
+    description: <<END
+2-D.  `N x R` matrix with the same indices as input_indices, but
+in canonical row-major ordering.
+END
+  }
+  out_arg {
+    name: "output_values"
+    description: <<END
+1-D.  `N` non-empty values corresponding to `output_indices`.
+END
+  }
+  summary: "Reorders a SparseTensor into the canonical, row-major ordering."
+  description: <<END
+Note that by convention, all sparse ops preserve the canonical ordering along
+increasing dimension number. The only time ordering can be violated is during
+manual manipulation of the indices and values vectors to add entries.
+
+Reordering does not affect the shape of the SparseTensor.
+
+If the tensor has rank `R` and `N` non-empty values, `input_indices` has
+shape `[N, R]`, input_values has length `N`, and input_shape has length `R`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseReshape.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseReshape.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..84fef9fbc4d037f91c0c74af55d00d014769c135
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseReshape.pbtxt
@@ -0,0 +1,55 @@
+op {
+  graph_op_name: "SparseReshape"
+  in_arg {
+    name: "input_indices"
+    description: <<END
+2-D.  `N x R_in` matrix with the indices of non-empty values in a
+SparseTensor.
+END
+  }
+  in_arg {
+    name: "input_shape"
+    description: <<END
+1-D.  `R_in` vector with the input SparseTensor's dense shape.
+END
+  }
+  in_arg {
+    name: "new_shape"
+    description: <<END
+1-D.  `R_out` vector with the requested new dense shape.
+END
+  }
+  out_arg {
+    name: "output_indices"
+    description: <<END
+2-D.  `N x R_out` matrix with the updated indices of non-empty
+values in the output SparseTensor.
+END
+  }
+  out_arg {
+    name: "output_shape"
+    description: <<END
+1-D.  `R_out` vector with the full dense shape of the output
+SparseTensor.  This is the same as `new_shape` but with any -1 dimensions
+filled in.
+END
+  }
+  summary: "Reshapes a SparseTensor to represent values in a new dense shape."
+  description: <<END
+This operation has the same semantics as reshape on the represented dense
+tensor.  The `input_indices` are recomputed based on the requested `new_shape`.
+
+If one component of `new_shape` is the special value -1, the size of that
+dimension is computed so that the total dense size remains constant.  At
+most one component of `new_shape` can be -1.  The number of dense elements
+implied by `new_shape` must be the same as the number of dense elements
+originally implied by `input_shape`.
+
+Reshaping does not affect the order of values in the SparseTensor.
+
+If the input tensor has rank `R_in` and `N` non-empty values, and `new_shape`
+has length `R_out`, then `input_indices` has shape `[N, R_in]`,
+`input_shape` has length `R_in`, `output_indices` has shape `[N, R_out]`, and
+`output_shape` has length `R_out`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseSegmentMean.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseSegmentMean.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..18e66605951afcba96f5e1cca10e959850ca2bf1
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseSegmentMean.pbtxt
@@ -0,0 +1,30 @@
+op {
+  graph_op_name: "SparseSegmentMean"
+  in_arg {
+    name: "indices"
+    description: <<END
+A 1-D tensor. Has same rank as `segment_ids`.
+END
+  }
+  in_arg {
+    name: "segment_ids"
+    description: <<END
+A 1-D tensor. Values should be sorted and can be repeated.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Has same shape as data, except for dimension 0 which
+has size `k`, the number of segments.
+END
+  }
+  summary: "Computes the mean along sparse segments of a tensor."
+  description: <<END
+Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
+segments.
+
+Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first
+dimension, selecting a subset of dimension 0, specified by `indices`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseSegmentMeanGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseSegmentMeanGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b58d6671b5f57d8b63efdd2057b3defd6b6b02d7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseSegmentMeanGrad.pbtxt
@@ -0,0 +1,32 @@
+op {
+  graph_op_name: "SparseSegmentMeanGrad"
+  in_arg {
+    name: "grad"
+    description: <<END
+gradient propagated to the SparseSegmentMean op.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+indices passed to the corresponding SparseSegmentMean op.
+END
+  }
+  in_arg {
+    name: "segment_ids"
+    description: <<END
+segment_ids passed to the corresponding SparseSegmentMean op.
+END
+  }
+  in_arg {
+    name: "output_dim0"
+    description: <<END
+dimension 0 of "data" passed to SparseSegmentMean op.
+END
+  }
+  summary: "Computes gradients for SparseSegmentMean."
+  description: <<END
+Returns tensor "output" with same shape as grad, except for dimension 0 whose
+value is output_dim0.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseSegmentSqrtN.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseSegmentSqrtN.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3fdeb66aed79f73b10096fafa8846e79a4180394
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseSegmentSqrtN.pbtxt
@@ -0,0 +1,29 @@
+op {
+  graph_op_name: "SparseSegmentSqrtN"
+  in_arg {
+    name: "indices"
+    description: <<END
+A 1-D tensor. Has same rank as `segment_ids`.
+END
+  }
+  in_arg {
+    name: "segment_ids"
+    description: <<END
+A 1-D tensor. Values should be sorted and can be repeated.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Has same shape as data, except for dimension 0 which
+has size `k`, the number of segments.
+END
+  }
+  summary: "Computes the sum along sparse segments of a tensor divided by the sqrt of N."
+  description: <<END
+N is the size of the segment being reduced.
+
+Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
+segments.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseSegmentSqrtNGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseSegmentSqrtNGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7cb2e29ef4a4b29b767cf5d0902d5cd05afe7b18
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseSegmentSqrtNGrad.pbtxt
@@ -0,0 +1,32 @@
+op {
+  graph_op_name: "SparseSegmentSqrtNGrad"
+  in_arg {
+    name: "grad"
+    description: <<END
+gradient propagated to the SparseSegmentSqrtN op.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+indices passed to the corresponding SparseSegmentSqrtN op.
+END
+  }
+  in_arg {
+    name: "segment_ids"
+    description: <<END
+segment_ids passed to the corresponding SparseSegmentSqrtN op.
+END
+  }
+  in_arg {
+    name: "output_dim0"
+    description: <<END
+dimension 0 of "data" passed to SparseSegmentSqrtN op.
+END
+  }
+  summary: "Computes gradients for SparseSegmentSqrtN."
+  description: <<END
+Returns tensor "output" with same shape as grad, except for dimension 0 whose
+value is output_dim0.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseSegmentSum.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseSegmentSum.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cdf44a89a386f7ab5fb702de96a83f307e531597
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseSegmentSum.pbtxt
@@ -0,0 +1,53 @@
+op {
+  graph_op_name: "SparseSegmentSum"
+  in_arg {
+    name: "indices"
+    description: <<END
+A 1-D tensor. Has same rank as `segment_ids`.
+END
+  }
+  in_arg {
+    name: "segment_ids"
+    description: <<END
+A 1-D tensor. Values should be sorted and can be repeated.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Has same shape as data, except for dimension 0 which
+has size `k`, the number of segments.
+END
+  }
+  summary: "Computes the sum along sparse segments of a tensor."
+  description: <<END
+Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
+segments.
+
+Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first
+dimension, selecting a subset of dimension 0, specified by `indices`.
+
+For example:
+
+```python
+c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
+
+# Select two rows, one segment.
+tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))
+# => [[0 0 0 0]]
+
+# Select two rows, two segment.
+tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))
+# => [[ 1  2  3  4]
+#     [-1 -2 -3 -4]]
+
+# Select all rows, two segments.
+tf.sparse_segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))
+# => [[0 0 0 0]
+#     [5 6 7 8]]
+
+# Which is equivalent to:
+tf.segment_sum(c, tf.constant([0, 0, 1]))
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseSlice.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseSlice.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..637ba6ece4253ae65f4f1b6bb6314a3c84e5ef72
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseSlice.pbtxt
@@ -0,0 +1,67 @@
+op {
+  graph_op_name: "SparseSlice"
+  in_arg {
+    name: "indices"
+    description: <<END
+2-D tensor represents the indices of the sparse tensor.
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+1-D tensor represents the values of the sparse tensor.
+END
+  }
+  in_arg {
+    name: "shape"
+    description: <<END
+1-D. tensor represents the shape of the sparse tensor.
+END
+  }
+  in_arg {
+    name: "start"
+    description: <<END
+1-D. tensor represents the start of the slice.
+END
+  }
+  in_arg {
+    name: "size"
+    description: <<END
+1-D. tensor represents the size of the slice.
+output indices: A list of 1-D tensors represents the indices of the output
+sparse tensors.
+END
+  }
+  out_arg {
+    name: "output_values"
+    description: <<END
+A list of 1-D tensors represents the values of the output sparse
+tensors.
+END
+  }
+  out_arg {
+    name: "output_shape"
+    description: <<END
+A list of 1-D tensors represents the shape of the output sparse
+tensors.
+END
+  }
+  summary: "Slice a `SparseTensor` based on the `start` and `size`."
+  description: <<END
+For example, if the input is
+
+    input_tensor = shape = [2, 7]
+    [    a   d e  ]
+    [b c          ]
+
+Graphically the output tensors are:
+
+    sparse_slice([0, 0], [2, 4]) = shape = [2, 4]
+    [    a  ]
+    [b c    ]
+
+    sparse_slice([0, 4], [2, 3]) = shape = [2, 3]
+    [ d e  ]
+    [      ]
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseSoftmax.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseSoftmax.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c64c3c68a19412a0f0eaf005491d54193baac0ae
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseSoftmax.pbtxt
@@ -0,0 +1,46 @@
+op {
+  graph_op_name: "SparseSoftmax"
+  in_arg {
+    name: "sp_indices"
+    description: <<END
+2-D.  `NNZ x R` matrix with the indices of non-empty values in a
+SparseTensor, in canonical ordering.
+END
+  }
+  in_arg {
+    name: "sp_values"
+    description: <<END
+1-D.  `NNZ` non-empty values corresponding to `sp_indices`.
+END
+  }
+  in_arg {
+    name: "sp_shape"
+    description: <<END
+1-D.  Shape of the input SparseTensor.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+1-D.  The `NNZ` values for the result `SparseTensor`.
+END
+  }
+  summary: "Applies softmax to a batched N-D `SparseTensor`."
+  description: <<END
+The inputs represent an N-D SparseTensor  with logical shape `[..., B, C]`
+(where `N >= 2`), and with indices sorted in the canonical lexicographic order.
+
+This op is equivalent to applying the normal `tf.nn.softmax()` to each innermost
+logical submatrix with shape `[B, C]`, but with the catch that *the implicitly
+zero elements do not participate*.  Specifically, the algorithm is equivalent
+to the following:
+
+  (1) Applies `tf.nn.softmax()` to a densified view of each innermost submatrix
+      with shape `[B, C]`, along the size-C dimension;
+  (2) Masks out the original implicitly-zero locations;
+  (3) Renormalizes the remaining elements.
+
+Hence, the `SparseTensor` result has exactly the same non-zero indices and
+shape.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseSoftmaxCrossEntropyWithLogits.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseSoftmaxCrossEntropyWithLogits.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a867bbe04d5ca2361395b859e70ce212b387a5e2
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseSoftmaxCrossEntropyWithLogits.pbtxt
@@ -0,0 +1,37 @@
+op {
+  graph_op_name: "SparseSoftmaxCrossEntropyWithLogits"
+  in_arg {
+    name: "features"
+    description: <<END
+batch_size x num_classes matrix
+END
+  }
+  in_arg {
+    name: "labels"
+    description: <<END
+batch_size vector with values in [0, num_classes).
+This is the label for the given minibatch entry.
+END
+  }
+  out_arg {
+    name: "loss"
+    description: <<END
+Per example loss (batch_size vector).
+END
+  }
+  out_arg {
+    name: "backprop"
+    description: <<END
+backpropagated gradients (batch_size x num_classes matrix).
+END
+  }
+  summary: "Computes softmax cross entropy cost and gradients to backpropagate."
+  description: <<END
+Unlike `SoftmaxCrossEntropyWithLogits`, this operation does not accept
+a matrix of label probabilities, but rather a single label per row
+of features.  This label is considered to have probability 1.0 for the
+given row.
+
+Inputs are the logits, not probabilities.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseSparseMaximum.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseSparseMaximum.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..34ccddd5d42b055b959c37d1c109565a902e1dcd
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseSparseMaximum.pbtxt
@@ -0,0 +1,56 @@
+op {
+  graph_op_name: "SparseSparseMaximum"
+  in_arg {
+    name: "a_indices"
+    description: <<END
+2-D.  `N x R` matrix with the indices of non-empty values in a
+SparseTensor, in the canonical lexicographic ordering.
+END
+  }
+  in_arg {
+    name: "a_values"
+    description: <<END
+1-D.  `N` non-empty values corresponding to `a_indices`.
+END
+  }
+  in_arg {
+    name: "a_shape"
+    description: <<END
+1-D.  Shape of the input SparseTensor.
+END
+  }
+  in_arg {
+    name: "b_indices"
+    description: <<END
+counterpart to `a_indices` for the other operand.
+END
+  }
+  in_arg {
+    name: "b_values"
+    description: <<END
+counterpart to `a_values` for the other operand; must be of the same dtype.
+END
+  }
+  in_arg {
+    name: "b_shape"
+    description: <<END
+counterpart to `a_shape` for the other operand; the two shapes must be equal.
+END
+  }
+  out_arg {
+    name: "output_indices"
+    description: <<END
+2-D.  The indices of the output SparseTensor.
+END
+  }
+  out_arg {
+    name: "output_values"
+    description: <<END
+1-D.  The values of the output SparseTensor.
+END
+  }
+  summary: "Returns the element-wise max of two SparseTensors."
+  description: <<END
+Assumes the two SparseTensors have the same shape, i.e., no broadcasting.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseSparseMinimum.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseSparseMinimum.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1b25684bb0061f0d649df3c774ec5fae85a9c91f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseSparseMinimum.pbtxt
@@ -0,0 +1,56 @@
+op {
+  graph_op_name: "SparseSparseMinimum"
+  in_arg {
+    name: "a_indices"
+    description: <<END
+2-D.  `N x R` matrix with the indices of non-empty values in a
+SparseTensor, in the canonical lexicographic ordering.
+END
+  }
+  in_arg {
+    name: "a_values"
+    description: <<END
+1-D.  `N` non-empty values corresponding to `a_indices`.
+END
+  }
+  in_arg {
+    name: "a_shape"
+    description: <<END
+1-D.  Shape of the input SparseTensor.
+END
+  }
+  in_arg {
+    name: "b_indices"
+    description: <<END
+counterpart to `a_indices` for the other operand.
+END
+  }
+  in_arg {
+    name: "b_values"
+    description: <<END
+counterpart to `a_values` for the other operand; must be of the same dtype.
+END
+  }
+  in_arg {
+    name: "b_shape"
+    description: <<END
+counterpart to `a_shape` for the other operand; the two shapes must be equal.
+END
+  }
+  out_arg {
+    name: "output_indices"
+    description: <<END
+2-D.  The indices of the output SparseTensor.
+END
+  }
+  out_arg {
+    name: "output_values"
+    description: <<END
+1-D.  The values of the output SparseTensor.
+END
+  }
+  summary: "Returns the element-wise min of two SparseTensors."
+  description: <<END
+Assumes the two SparseTensors have the same shape, i.e., no broadcasting.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseSplit.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseSplit.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cc90ad333b2ffacb0d3dec247fe7963679233c5a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseSplit.pbtxt
@@ -0,0 +1,70 @@
+op {
+  graph_op_name: "SparseSplit"
+  in_arg {
+    name: "split_dim"
+    description: <<END
+0-D.  The dimension along which to split.  Must be in the range
+`[0, rank(shape))`.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+2-D tensor represents the indices of the sparse tensor.
+END
+  }
+  in_arg {
+    name: "values"
+    description: <<END
+1-D tensor represents the values of the sparse tensor.
+END
+  }
+  in_arg {
+    name: "shape"
+    description: <<END
+1-D. tensor represents the shape of the sparse tensor.
+output indices: A list of 1-D tensors represents the indices of the output
+sparse tensors.
+END
+  }
+  out_arg {
+    name: "output_values"
+    description: <<END
+A list of 1-D tensors represents the values of the output sparse
+tensors.
+END
+  }
+  out_arg {
+    name: "output_shape"
+    description: <<END
+A list of 1-D tensors represents the shape of the output sparse
+tensors.
+END
+  }
+  attr {
+    name: "num_split"
+    description: <<END
+The number of ways to split.
+END
+  }
+  summary: "Split a `SparseTensor` into `num_split` tensors along one dimension."
+  description: <<END
+If the `shape[split_dim]` is not an integer multiple of `num_split`. Slices
+`[0 : shape[split_dim] % num_split]` gets one extra dimension.
+For example, if `split_dim = 1` and `num_split = 2` and the input is
+
+    input_tensor = shape = [2, 7]
+    [    a   d e  ]
+    [b c          ]
+
+Graphically the output tensors are:
+
+    output_tensor[0] = shape = [2, 4]
+    [    a  ]
+    [b c    ]
+
+    output_tensor[1] = shape = [2, 3]
+    [ d e  ]
+    [      ]
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseTensorDenseAdd.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseTensorDenseAdd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7225447188b9b356411ddc230af75eb0976c2945
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseTensorDenseAdd.pbtxt
@@ -0,0 +1,31 @@
+op {
+  graph_op_name: "SparseTensorDenseAdd"
+  in_arg {
+    name: "a_indices"
+    description: <<END
+2-D.  The `indices` of the `SparseTensor`, with shape `[nnz, ndims]`.
+END
+  }
+  in_arg {
+    name: "a_values"
+    description: <<END
+1-D.  The `values` of the `SparseTensor`, with shape `[nnz]`.
+END
+  }
+  in_arg {
+    name: "a_shape"
+    description: <<END
+1-D.  The `shape` of the `SparseTensor`, with shape `[ndims]`.
+END
+  }
+  in_arg {
+    name: "b"
+    description: <<END
+`ndims`-D Tensor.  With shape `a_shape`.
+END
+  }
+  summary: "Adds up a `SparseTensor` and a dense `Tensor`, producing a dense `Tensor`."
+  description: <<END
+This Op does not require `a_indices` be sorted in standard lexicographic order.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseTensorDenseMatMul.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseTensorDenseMatMul.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0a5dc08d212acc1bb8d48178ac163dd7b1ce2b26
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseTensorDenseMatMul.pbtxt
@@ -0,0 +1,53 @@
+op {
+  graph_op_name: "SparseTensorDenseMatMul"
+  in_arg {
+    name: "a_indices"
+    description: <<END
+2-D.  The `indices` of the `SparseTensor`, size `[nnz, 2]` Matrix.
+END
+  }
+  in_arg {
+    name: "a_values"
+    description: <<END
+1-D.  The `values` of the `SparseTensor`, size `[nnz]` Vector.
+END
+  }
+  in_arg {
+    name: "a_shape"
+    description: <<END
+1-D.  The `shape` of the `SparseTensor`, size `[2]` Vector.
+END
+  }
+  in_arg {
+    name: "b"
+    description: <<END
+2-D.  A dense Matrix.
+END
+  }
+  attr {
+    name: "adjoint_a"
+    description: <<END
+Use the adjoint of A in the matrix multiply.  If A is complex, this
+is transpose(conj(A)).  Otherwise it's transpose(A).
+END
+  }
+  attr {
+    name: "adjoint_b"
+    description: <<END
+Use the adjoint of B in the matrix multiply.  If B is complex, this
+is transpose(conj(B)).  Otherwise it's transpose(B).
+END
+  }
+  summary: "Multiply SparseTensor (of rank 2) \"A\" by dense matrix \"B\"."
+  description: <<END
+No validity checking is performed on the indices of A.  However, the following
+input format is recommended for optimal behavior:
+
+if adjoint_a == false:
+  A should be sorted in lexicographically increasing order.  Use SparseReorder
+  if you're not sure.
+if adjoint_a == true:
+  A should be sorted in order of increasing dimension 1 (i.e., "column major"
+  order instead of "row major" order).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseTensorSliceDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseTensorSliceDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ffb805834908103865e5fcb8d98fb080d60a44ab
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseTensorSliceDataset.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SparseTensorSliceDataset"
+  summary: "Creates a dataset that splits a SparseTensor into elements row-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseToDense.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseToDense.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5fb0012d042789fab2e13e34353532cd2c36d453
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseToDense.pbtxt
@@ -0,0 +1,65 @@
+op {
+  graph_op_name: "SparseToDense"
+  in_arg {
+    name: "sparse_indices"
+    description: <<END
+0-D, 1-D, or 2-D.  `sparse_indices[i]` contains the complete
+index where `sparse_values[i]` will be placed.
+END
+  }
+  in_arg {
+    name: "output_shape"
+    description: <<END
+1-D.  Shape of the dense output tensor.
+END
+  }
+  in_arg {
+    name: "sparse_values"
+    description: <<END
+1-D.  Values corresponding to each row of `sparse_indices`,
+or a scalar value to be used for all sparse indices.
+END
+  }
+  in_arg {
+    name: "default_value"
+    description: <<END
+Scalar value to set for indices not specified in
+`sparse_indices`.
+END
+  }
+  out_arg {
+    name: "dense"
+    description: <<END
+Dense output tensor of shape `output_shape`.
+END
+  }
+  attr {
+    name: "validate_indices"
+    description: <<END
+If true, indices are checked to make sure they are sorted in
+lexicographic order and that there are no repeats.
+END
+  }
+  summary: "Converts a sparse representation into a dense tensor."
+  description: <<END
+Builds an array `dense` with shape `output_shape` such that
+
+```
+# If sparse_indices is scalar
+dense[i] = (i == sparse_indices ? sparse_values : default_value)
+
+# If sparse_indices is a vector, then for each i
+dense[sparse_indices[i]] = sparse_values[i]
+
+# If sparse_indices is an n by d matrix, then for each i in [0, n)
+dense[sparse_indices[i][0], ..., sparse_indices[i][d-1]] = sparse_values[i]
+```
+
+All other values in `dense` are set to `default_value`.  If `sparse_values` is a
+scalar, all sparse indices are set to this single value.
+
+Indices should be sorted in lexicographic order, and indices must not
+contain any repeats. If `validate_indices` is true, these properties
+are checked during execution.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseToSparseSetOperation.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseToSparseSetOperation.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..766f756bb58e05a38451443295551dec045a12c2
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SparseToSparseSetOperation.pbtxt
@@ -0,0 +1,93 @@
+op {
+  graph_op_name: "SparseToSparseSetOperation"
+  in_arg {
+    name: "set1_indices"
+    description: <<END
+2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
+order.
+END
+  }
+  in_arg {
+    name: "set1_values"
+    description: <<END
+1D `Tensor`, values of a `SparseTensor`. Must be in row-major
+order.
+END
+  }
+  in_arg {
+    name: "set1_shape"
+    description: <<END
+1D `Tensor`, shape of a `SparseTensor`. `set1_shape[0...n-1]` must
+be the same as `set2_shape[0...n-1]`, `set1_shape[n]` is the
+max set size across `0...n-1` dimensions.
+END
+  }
+  in_arg {
+    name: "set2_indices"
+    description: <<END
+2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
+order.
+END
+  }
+  in_arg {
+    name: "set2_values"
+    description: <<END
+1D `Tensor`, values of a `SparseTensor`. Must be in row-major
+order.
+END
+  }
+  in_arg {
+    name: "set2_shape"
+    description: <<END
+1D `Tensor`, shape of a `SparseTensor`. `set2_shape[0...n-1]` must
+be the same as `set1_shape[0...n-1]`, `set2_shape[n]` is the
+max set size across `0...n-1` dimensions.
+END
+  }
+  out_arg {
+    name: "result_indices"
+    description: <<END
+2D indices of a `SparseTensor`.
+END
+  }
+  out_arg {
+    name: "result_values"
+    description: <<END
+1D values of a `SparseTensor`.
+END
+  }
+  out_arg {
+    name: "result_shape"
+    description: <<END
+1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
+the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
+is the max result set size across all `0...n-1` dimensions.
+END
+  }
+  summary: "Applies set operation along last dimension of 2 `SparseTensor` inputs."
+  description: <<END
+See SetOperationOp::SetOperationFromContext for values of `set_operation`.
+
+If `validate_indices` is `True`, `SparseToSparseSetOperation` validates the
+order and range of `set1` and `set2` indices.
+
+Input `set1` is a `SparseTensor` represented by `set1_indices`, `set1_values`,
+and `set1_shape`. For `set1` ranked `n`, 1st `n-1` dimensions must be the same
+as `set2`. Dimension `n` contains values in a set, duplicates are allowed but
+ignored.
+
+Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`,
+and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same
+as `set1`. Dimension `n` contains values in a set, duplicates are allowed but
+ignored.
+
+If `validate_indices` is `True`, this op validates the order and range of `set1`
+and `set2` indices.
+
+Output `result` is a `SparseTensor` represented by `result_indices`,
+`result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
+has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
+dimension contains the result of `set_operation` applied to the corresponding
+`[0...n-1]` dimension of `set`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Split.pbtxt b/tensorflow/core/api_def/base_api/api_def_Split.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..802f440896baf5817ce07bf6a1ead21b656141ec
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Split.pbtxt
@@ -0,0 +1,33 @@
+op {
+  graph_op_name: "Split"
+  in_arg {
+    name: "split_dim"
+    rename_to: "axis"
+    description: <<END
+0-D.  The dimension along which to split.  Must be in the range
+`[-rank(value), rank(value))`.
+END
+  }
+  in_arg {
+    name: "value"
+    description: <<END
+The tensor to split.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+They are identically shaped tensors, whose shape matches that of `value`
+except along `split_dim`, where their sizes are
+`values.shape[split_dim] / num_split`.
+END
+  }
+  attr {
+    name: "num_split"
+    description: <<END
+The number of ways to split.  Must evenly divide
+`value.shape[split_dim]`.
+END
+  }
+  summary: "Splits a tensor into `num_split` tensors along one dimension."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SplitV.pbtxt b/tensorflow/core/api_def/base_api/api_def_SplitV.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6c1660ffb60ff1127e512793acb0dc1019416faa
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SplitV.pbtxt
@@ -0,0 +1,34 @@
+op {
+  graph_op_name: "SplitV"
+  in_arg {
+    name: "value"
+    description: <<END
+The tensor to split.
+END
+  }
+  in_arg {
+    name: "size_splits"
+    description: <<END
+list containing the sizes of each output tensor along the split
+dimension. Must sum to the dimension of value along split_dim.
+Can contain one -1 indicating that dimension is to be inferred.
+END
+  }
+  in_arg {
+    name: "split_dim"
+    rename_to: "axis"
+    description: <<END
+0-D.  The dimension along which to split.  Must be in the range
+`[-rank(value), rank(value))`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Tensors whose shape matches that of `value`
+except along `split_dim`, where their sizes are
+`size_splits[i]`.
+END
+  }
+  summary: "Splits a tensor into `num_split` tensors along one dimension."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SqlDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_SqlDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7570d5da5662b8eab90e7dd00f8cb225a963d373
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SqlDataset.pbtxt
@@ -0,0 +1,22 @@
+op {
+  graph_op_name: "SqlDataset"
+  in_arg {
+    name: "driver_name"
+    description: <<END
+The database type. Currently, the only supported type is 'sqlite'.
+END
+  }
+  in_arg {
+    name: "data_source_name"
+    description: <<END
+A connection string to connect to the database.
+END
+  }
+  in_arg {
+    name: "query"
+    description: <<END
+A SQL query to execute.
+END
+  }
+  summary: "Creates a dataset that executes a SQL query and emits rows of the result set."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Sqrt.pbtxt b/tensorflow/core/api_def/base_api/api_def_Sqrt.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..857841dc41fcc177bb7141692aa8531257826d26
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Sqrt.pbtxt
@@ -0,0 +1,7 @@
+op {
+  graph_op_name: "Sqrt"
+  summary: "Computes square root of x element-wise."
+  description: <<END
+I.e., \\(y = \sqrt{x} = x^{1/2}\\).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SqrtGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_SqrtGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ac5b737f93511447da13dd441b8428dcf3872bd4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SqrtGrad.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "SqrtGrad"
+  visibility: HIDDEN
+  summary: "Computes the gradient for the sqrt of `x` wrt its input."
+  description: <<END
+Specifically, `grad = dy * 0.5 / y`, where `y = sqrt(x)`, and `dy`
+is the corresponding input gradient.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Square.pbtxt b/tensorflow/core/api_def/base_api/api_def_Square.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c3e32a98d154c68756b9c50b053c49c15bfde536
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Square.pbtxt
@@ -0,0 +1,7 @@
+op {
+  graph_op_name: "Square"
+  summary: "Computes square of x element-wise."
+  description: <<END
+I.e., \\(y = x * x = x^2\\).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SquaredDifference.pbtxt b/tensorflow/core/api_def/base_api/api_def_SquaredDifference.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..51277692d8c54a23354af33f556d4f61c0601f02
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SquaredDifference.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "SquaredDifference"
+  summary: "Returns (x - y)(x - y) element-wise."
+  description: <<END
+*NOTE*: `SquaredDifference` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Squeeze.pbtxt b/tensorflow/core/api_def/base_api/api_def_Squeeze.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f84c51536b087ff018c870409e941880c5be74c7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Squeeze.pbtxt
@@ -0,0 +1,46 @@
+op {
+  graph_op_name: "Squeeze"
+  in_arg {
+    name: "input"
+    description: <<END
+The `input` to squeeze.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Contains the same data as `input`, but has one or more dimensions of
+size 1 removed.
+END
+  }
+  attr {
+    name: "squeeze_dims"
+    rename_to: "axis"
+    description: <<END
+If specified, only squeezes the dimensions listed. The dimension
+index starts at 0. It is an error to squeeze a dimension that is not 1. Must
+be in the range `[-rank(input), rank(input))`.
+END
+  }
+  summary: "Removes dimensions of size 1 from the shape of a tensor."
+  description: <<END
+Given a tensor `input`, this operation returns a tensor of the same type with
+all dimensions of size 1 removed. If you don't want to remove all size 1
+dimensions, you can remove specific size 1 dimensions by specifying
+`squeeze_dims`.
+
+For example:
+
+```
+# 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
+shape(squeeze(t)) ==> [2, 3]
+```
+
+Or, to remove specific size 1 dimensions:
+
+```
+# 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
+shape(squeeze(t, [2, 4])) ==> [1, 2, 3, 1]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Stack.pbtxt b/tensorflow/core/api_def/base_api/api_def_Stack.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3fd668213008c872e86ef0f7132032b250359e03
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Stack.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "Stack"
+  visibility: SKIP
+  summary: "Deprecated, use StackV2."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StackClose.pbtxt b/tensorflow/core/api_def/base_api/api_def_StackClose.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..050d69cbaa0f35ce8960a4ec1a6790be701183c7
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StackClose.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "StackClose"
+  visibility: SKIP
+  summary: "Deprecated, use StackCloseV2."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StackCloseV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_StackCloseV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d9b71fec3b83e4208401970fafdf127262930c52
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StackCloseV2.pbtxt
@@ -0,0 +1,11 @@
+op {
+  graph_op_name: "StackCloseV2"
+  visibility: SKIP
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a stack.
+END
+  }
+  summary: "Delete the stack from its resource container."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StackPop.pbtxt b/tensorflow/core/api_def/base_api/api_def_StackPop.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..abf45f85cc026606461bebef34475216ca14f90c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StackPop.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "StackPop"
+  visibility: SKIP
+  summary: "Deprecated, use StackPopV2."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StackPopV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_StackPopV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7e0498dcf3fb41f8c77c956467573237582bbbab
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StackPopV2.pbtxt
@@ -0,0 +1,23 @@
+op {
+  graph_op_name: "StackPopV2"
+  visibility: SKIP
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a stack.
+END
+  }
+  out_arg {
+    name: "elem"
+    description: <<END
+The tensor that is popped from the top of the stack.
+END
+  }
+  attr {
+    name: "elem_type"
+    description: <<END
+The type of the elem that is popped.
+END
+  }
+  summary: "Pop the element at the top of the stack."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StackPush.pbtxt b/tensorflow/core/api_def/base_api/api_def_StackPush.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..619f20f9aada53ac61cd3e5902691eae89f16522
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StackPush.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "StackPush"
+  visibility: SKIP
+  summary: "Deprecated, use StackPushV2."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StackPushV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_StackPushV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..83d7dd1f35b4beaff86ae10e14cdfa969385aff6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StackPushV2.pbtxt
@@ -0,0 +1,29 @@
+op {
+  graph_op_name: "StackPushV2"
+  visibility: SKIP
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a stack.
+END
+  }
+  in_arg {
+    name: "elem"
+    description: <<END
+The tensor to be pushed onto the stack.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The same tensor as the input 'elem'.
+END
+  }
+  attr {
+    name: "swap_memory"
+    description: <<END
+Swap `elem` to CPU. Default to false.
+END
+  }
+  summary: "Push an element onto the stack."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StackV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_StackV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1699da1271693245aac3eca57e73838b4322ffaa
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StackV2.pbtxt
@@ -0,0 +1,31 @@
+op {
+  graph_op_name: "StackV2"
+  visibility: SKIP
+  in_arg {
+    name: "max_size"
+    description: <<END
+The maximum size of the stack if non-negative. If negative, the stack
+size is unlimited.
+END
+  }
+  out_arg {
+    name: "handle"
+    description: <<END
+The handle to the stack.
+END
+  }
+  attr {
+    name: "elem_type"
+    description: <<END
+The type of the elements on the stack.
+END
+  }
+  attr {
+    name: "stack_name"
+    description: <<END
+Overrides the name used for the temporary stack resource. Default
+value is the name of the 'Stack' op (which is guaranteed unique).
+END
+  }
+  summary: "A stack that produces elements in first-in last-out order."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Stage.pbtxt b/tensorflow/core/api_def/base_api/api_def_Stage.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ba9b4bc461d1a07d13eb9f844a08864a4befa2c5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Stage.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "Stage"
+  in_arg {
+    name: "values"
+    description: <<END
+a list of tensors
+dtypes A list of data types that inserted values should adhere to.
+END
+  }
+  attr {
+    name: "capacity"
+    description: <<END
+Maximum number of elements in the Staging Area. If > 0, inserts
+on the container will block when the capacity is reached.
+END
+  }
+  attr {
+    name: "memory_limit"
+    description: <<END
+The maximum number of bytes allowed for Tensors in the Staging Area.
+If > 0, inserts will block until sufficient space is available.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this queue is placed in the given container. Otherwise,
+a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+It is necessary to match this name to the matching Unstage Op.
+END
+  }
+  summary: "Stage values similar to a lightweight Enqueue."
+  description: <<END
+The basic functionality of this Op is similar to a queue with many
+fewer capabilities and options.  This Op is optimized for performance.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StageClear.pbtxt b/tensorflow/core/api_def/base_api/api_def_StageClear.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..22cbe41090c8060548ab44e2e44a9f6854d8e5b8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StageClear.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "StageClear"
+  summary: "Op removes all elements in the underlying container."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StagePeek.pbtxt b/tensorflow/core/api_def/base_api/api_def_StagePeek.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7eba72af2a293bde4b692bbe00bca5b5b59b58de
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StagePeek.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "StagePeek"
+  summary: "Op peeks at the values at the specified index.  If the"
+  description: <<END
+underlying container does not contain sufficient elements
+this op will block until it does.   This Op is optimized for
+performance.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StageSize.pbtxt b/tensorflow/core/api_def/base_api/api_def_StageSize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7ae827d1b5dcd0f1f05c437317cd388cca3dde4b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StageSize.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "StageSize"
+  summary: "Op returns the number of elements in the underlying container."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StatelessRandomNormal.pbtxt b/tensorflow/core/api_def/base_api/api_def_StatelessRandomNormal.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b6ef8160e4818519ce503076c719697dd06a419c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StatelessRandomNormal.pbtxt
@@ -0,0 +1,33 @@
+op {
+  graph_op_name: "StatelessRandomNormal"
+  in_arg {
+    name: "shape"
+    description: <<END
+The shape of the output tensor.
+END
+  }
+  in_arg {
+    name: "seed"
+    description: <<END
+2 seeds (shape [2]).
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Random values with specified shape.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of the output.
+END
+  }
+  summary: "Outputs deterministic pseudorandom values from a normal distribution."
+  description: <<END
+The generated values will have mean 0 and standard deviation 1.
+
+The outputs are a deterministic function of `shape` and `seed`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StatelessRandomUniform.pbtxt b/tensorflow/core/api_def/base_api/api_def_StatelessRandomUniform.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0ba88c3730793b9066fbcafc195529d0fccb6eb1
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StatelessRandomUniform.pbtxt
@@ -0,0 +1,34 @@
+op {
+  graph_op_name: "StatelessRandomUniform"
+  in_arg {
+    name: "shape"
+    description: <<END
+The shape of the output tensor.
+END
+  }
+  in_arg {
+    name: "seed"
+    description: <<END
+2 seeds (shape [2]).
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Random values with specified shape.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of the output.
+END
+  }
+  summary: "Outputs deterministic pseudorandom random values from a uniform distribution."
+  description: <<END
+The generated values follow a uniform distribution in the range `[0, 1)`. The
+lower bound 0 is included in the range, while the upper bound 1 is excluded.
+
+The outputs are a deterministic function of `shape` and `seed`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StatelessTruncatedNormal.pbtxt b/tensorflow/core/api_def/base_api/api_def_StatelessTruncatedNormal.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..37228dba648d90dac7f1f4051dc5be1bee137781
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StatelessTruncatedNormal.pbtxt
@@ -0,0 +1,35 @@
+op {
+  graph_op_name: "StatelessTruncatedNormal"
+  in_arg {
+    name: "shape"
+    description: <<END
+The shape of the output tensor.
+END
+  }
+  in_arg {
+    name: "seed"
+    description: <<END
+2 seeds (shape [2]).
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Random values with specified shape.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of the output.
+END
+  }
+  summary: "Outputs deterministic pseudorandom values from a truncated normal distribution."
+  description: <<END
+The generated values follow a normal distribution with mean 0 and standard
+deviation 1, except that values whose magnitude is more than 2 standard
+deviations from the mean are dropped and re-picked.
+
+The outputs are a deterministic function of `shape` and `seed`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StopGradient.pbtxt b/tensorflow/core/api_def/base_api/api_def_StopGradient.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..af4b9f6113cb9b76734892ec39e08dad6ffbcc1c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StopGradient.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "StopGradient"
+  summary: "Stops gradient computation."
+  description: <<END
+When executed in a graph, this op outputs its input tensor as-is.
+
+When building ops to compute gradients, this op prevents the contribution of
+its inputs to be taken into account.  Normally, the gradient generator adds ops
+to a graph to compute the derivatives of a specified 'loss' by recursively
+finding out inputs that contributed to its computation.  If you insert this op
+in the graph it inputs are masked from the gradient generator.  They are not
+taken into account for computing gradients.
+
+This is useful any time you want to compute a value with TensorFlow but need
+to pretend that the value was a constant. Some examples include:
+
+*  The *EM* algorithm where the *M-step* should not involve backpropagation
+   through the output of the *E-step*.
+*  Contrastive divergence training of Boltzmann machines where, when
+   differentiating the energy function, the training must not backpropagate
+   through the graph that generated the samples from the model.
+*  Adversarial training, where no backprop should happen through the adversarial
+   example generation process.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StridedSlice.pbtxt b/tensorflow/core/api_def/base_api/api_def_StridedSlice.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8d6fc048471d86392c09425371169054755c5af2
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StridedSlice.pbtxt
@@ -0,0 +1,167 @@
+op {
+  graph_op_name: "StridedSlice"
+  in_arg {
+    name: "begin"
+    description: <<END
+`begin[k]` specifies the offset into the `k`th range specification.
+The exact dimension this corresponds to will be determined by context.
+Out-of-bounds values will be silently clamped. If the `k`th bit of
+`begin_mask` then `begin[k]` is ignored and the full range of the
+appropriate dimension is used instead. Negative values causes indexing
+to start from the highest element e.g. If `foo==[1,2,3]` then `foo[-1]==3`.
+END
+  }
+  in_arg {
+    name: "end"
+    description: <<END
+`end[i]` is like `begin` with the exception that `end_mask` is
+used to determine full ranges.
+END
+  }
+  in_arg {
+    name: "strides"
+    description: <<END
+`strides[i]` specifies the increment in the `i`th specification
+after extracting a given element. Negative indices will reverse
+the original order. Out or range values are
+clamped to `[0,dim[i]) if slice[i]>0` or `[-1,dim[i]-1] if slice[i] < 0`
+END
+  }
+  attr {
+    name: "begin_mask"
+    description: <<END
+a bitmask where a bit i being 1 means to ignore the begin
+value and instead use the largest interval possible. At runtime
+begin[i] will be replaced with `[0, n-1) if `stride[i] > 0` or
+`[-1, n-1]` if `stride[i] < 0`
+END
+  }
+  attr {
+    name: "end_mask"
+    description: <<END
+analogous to `begin_mask`
+END
+  }
+  attr {
+    name: "ellipsis_mask"
+    description: <<END
+a bitmask where bit `i` being 1 means the `i`th
+position is actually an ellipsis. One bit at most can be 1.
+If `ellipsis_mask == 0`, then an implicit ellipsis mask of `1 << (m+1)`
+is provided. This means that `foo[3:5] == foo[3:5, ...]`. An ellipsis
+implicitly creates as many range specifications as necessary to fully
+specify the sliced range for every dimension. For example for a 4-dimensional
+tensor `foo` the slice `foo[2, ..., 5:8]` implies `foo[2, :, :, 5:8]`.
+END
+  }
+  attr {
+    name: "new_axis_mask"
+    description: <<END
+a bitmask where bit `i` being 1 means the `i`th
+specification creates a new shape 1 dimension. For example
+`foo[:4, tf.newaxis, :2]` would produce a shape `(4, 1, 2)` tensor.
+END
+  }
+  attr {
+    name: "shrink_axis_mask"
+    description: <<END
+a bitmask where bit `i` implies that the `i`th
+specification should shrink the dimensionality. begin and end
+must imply a slice of size 1 in the dimension. For example in
+python one might do `foo[:, 3, :]` which would result in
+`shrink_axis_mask` being 2.
+END
+  }
+  summary: "Return a strided slice from `input`."
+  description: <<END
+Note, most python users will want to use the Python `Tensor.__getitem__`
+or `Variable.__getitem__` rather than this op directly.
+
+The goal of this op is to produce a new tensor with a subset of
+the elements from the `n` dimensional `input` tensor. The subset is chosen using
+a sequence of `m` sparse range specifications encoded into the arguments
+of this function. Note, in some cases
+`m` could be equal to `n`, but this need not be the case. Each
+range specification entry can be one of the following:
+
+- An ellipsis (...). Ellipses are used to imply zero or more
+  dimensions of full-dimension selection and are produced using
+  `ellipsis_mask`. For example, `foo[...]` is the identity slice.
+
+- A new axis. This is used to insert a new shape=1 dimension and is
+  produced using `new_axis_mask`. For example, `foo[:, ...]` where
+  `foo` is shape `(3, 4)` produces a `(1, 3, 4)` tensor.
+
+
+- A range `begin:end:stride`. This is used to specify how much to choose from
+  a given dimension. `stride` can be any integer but 0.  `begin` is an integer
+  which represents the index of the first value to select while `end` represents
+  the index of the last value to select. The number of values selected in each
+  dimension is `end - begin` if `stride > 0` and `begin - end` if `stride < 0`.
+  `begin` and `end` can be negative where `-1` is the last element, `-2` is
+  the second to last. `begin_mask` controls whether to replace the explicitly
+  given `begin` with an implicit effective value of `0` if `stride > 0` and
+  `-1` if `stride < 0`. `end_mask` is analogous but produces the number
+  required to create the largest open interval. For example, given a shape
+  `(3,)` tensor `foo[:]`, the effective `begin` and `end` are `0` and `3`. Do
+  not assume this is equivalent to `foo[0:-1]` which has an effective `begin`
+  and `end` of `0` and `2`. Another example is `foo[-2::-1]` which reverses the
+  first dimension of a tensor while dropping the last two (in the original
+  order elements). For example `foo = [1,2,3,4]; foo[-2::-1]` is `[4,3]`.
+
+- A single index. This is used to keep only elements that have a given
+  index. For example (`foo[2, :]` on a shape `(5,6)` tensor produces a
+  shape `(6,)` tensor. This is encoded in `begin` and `end` and
+  `shrink_axis_mask`.
+
+Each conceptual range specification is encoded in the op's argument. This
+encoding is best understand by considering a non-trivial example. In
+particular,
+`foo[1, 2:4, None, ..., :-3:-1, :]` will be encoded as
+
+```
+begin = [1, 2, x, x, 0, x] # x denotes don't care (usually 0)
+end = [2, 4, x, x, -3, x]
+strides = [1, 1, x, x, -1, 1]
+begin_mask = 1<<4 | 1 << 5 = 48
+end_mask = 1<<5 = 32
+ellipsis_mask = 1<<3 = 8
+new_axis_mask = 1<<2 4
+shrink_axis_mask = 1<<0
+```
+
+In this case if `foo.shape` is (5, 5, 5, 5, 5, 5) the final shape of
+the slice becomes (2, 1, 5, 5, 2, 5).
+Let us walk step by step through each argument specification.
+
+1.  The first argument in the example slice is turned into `begin = 1` and
+`end = begin + 1 = 2`. To disambiguate from the original spec `2:4` we
+also set the appropriate bit in `shrink_axis_mask`.
+
+2. `2:4` is contributes 2, 4, 1 to begin, end, and stride. All masks have
+zero bits contributed.
+
+3. None is a synonym for `tf.newaxis`. This means insert a dimension of size 1
+dimension in the final shape. Dummy values are contributed to begin,
+end and stride, while the new_axis_mask bit is set.
+
+4. `...` grab the full ranges from as many dimensions as needed to
+fully specify a slice for every dimension of the input shape.
+
+5. `:-3:-1` shows the use of negative indices. A negative index `i` associated
+with a dimension that has shape `s` is converted to a positive index
+`s + i`. So `-1` becomes `s-1` (i.e. the last element). This conversion
+is done internally so begin, end and strides receive x, -3, and -1.
+The appropriate begin_mask bit is set to indicate the start range is the
+full range (ignoring the x).
+
+6. `:` indicates that the entire contents of the corresponding dimension
+is selected. This is equivalent to `::` or `0::1`. begin, end, and strides
+receive 0, 0, and 1, respectively. The appropriate bits in `begin_mask` and
+`end_mask` are also set.
+
+*Requirements*:
+  `0 != strides[i] for i in [0, m)`
+  `ellipsis_mask must be a power of two (only one ellipsis)`
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StridedSliceAssign.pbtxt b/tensorflow/core/api_def/base_api/api_def_StridedSliceAssign.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0fc89576ad29939837da7c55e393a0baeca90e5e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StridedSliceAssign.pbtxt
@@ -0,0 +1,12 @@
+op {
+  graph_op_name: "StridedSliceAssign"
+  summary: "Assign `value` to the sliced l-value reference of `ref`."
+  description: <<END
+The values of `value` are assigned to the positions in the variable
+`ref` that are selected by the slice parameters. The slice parameters
+`begin, `end`, `strides`, etc. work exactly as in `StridedSlice`.
+
+NOTE this op currently does not support broadcasting and so `value`'s
+shape must be exactly the shape produced by the slice of `ref`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StridedSliceGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_StridedSliceGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c5ea059e8a410048ae3b91504f2d1ac63a641dc5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StridedSliceGrad.pbtxt
@@ -0,0 +1,14 @@
+op {
+  graph_op_name: "StridedSliceGrad"
+  summary: "Returns the gradient of `StridedSlice`."
+  description: <<END
+Since `StridedSlice` cuts out pieces of its `input` which is size
+`shape`, its gradient will have the same shape (which is passed here
+as `shape`). The gradient will be zero in any element that the slice
+does not select.
+
+Arguments are the same as StridedSliceGrad with the exception that
+`dy` is the input gradient to be propagated and `shape` is the
+shape of `StridedSlice`'s `input`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StringJoin.pbtxt b/tensorflow/core/api_def/base_api/api_def_StringJoin.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..549ee434130cae8f05543be1163b7e0b908dd549
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StringJoin.pbtxt
@@ -0,0 +1,21 @@
+op {
+  graph_op_name: "StringJoin"
+  in_arg {
+    name: "inputs"
+    description: <<END
+A list of string tensors.  The tensors must all have the same shape,
+or be scalars.  Scalars may be mixed in; these will be broadcast to the shape
+of non-scalar inputs.
+END
+  }
+  attr {
+    name: "separator"
+    description: <<END
+string, an optional join separator.
+END
+  }
+  summary: "Joins the strings in the given list of string tensors into one tensor;"
+  description: <<END
+with the given separator (default is an empty separator).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StringSplit.pbtxt b/tensorflow/core/api_def/base_api/api_def_StringSplit.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4792f298eef619eb8a9e1176cb5b237d771df681
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StringSplit.pbtxt
@@ -0,0 +1,64 @@
+op {
+  graph_op_name: "StringSplit"
+  in_arg {
+    name: "input"
+    description: <<END
+1-D. Strings to split.
+END
+  }
+  in_arg {
+    name: "delimiter"
+    description: <<END
+0-D. Delimiter characters (bytes), or empty string.
+END
+  }
+  out_arg {
+    name: "indices"
+    description: <<END
+A dense matrix of int64 representing the indices of the sparse tensor.
+END
+  }
+  out_arg {
+    name: "values"
+    description: <<END
+A vector of strings corresponding to the splited values.
+END
+  }
+  out_arg {
+    name: "shape"
+    description: <<END
+a length-2 vector of int64 representing the shape of the sparse
+tensor, where the first value is N and the second value is the maximum number
+of tokens in a single input entry.
+END
+  }
+  attr {
+    name: "skip_empty"
+    description: <<END
+A `bool`. If `True`, skip the empty strings from the result.
+END
+  }
+  summary: "Split elements of `input` based on `delimiter` into a `SparseTensor`."
+  description: <<END
+Let N be the size of source (typically N will be the batch size). Split each
+element of `input` based on `delimiter` and return a `SparseTensor`
+containing the splitted tokens. Empty tokens are ignored.
+
+`delimiter` can be empty, or a string of split characters. If `delimiter` is an
+ empty string, each element of `input` is split into individual single-byte
+ character strings, including splitting of UTF-8 multibyte sequences. Otherwise
+ every character of `delimiter` is a potential split point.
+
+For example:
+  N = 2, input[0] is 'hello world' and input[1] is 'a b c', then the output
+  will be
+
+  indices = [0, 0;
+             0, 1;
+             1, 0;
+             1, 1;
+             1, 2]
+  shape = [2, 3]
+  values = ['hello', 'world', 'a', 'b', 'c']
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StringToHashBucket.pbtxt b/tensorflow/core/api_def/base_api/api_def_StringToHashBucket.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..af49dbd161de09bfe2af3472ca25ba867d8a7580
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StringToHashBucket.pbtxt
@@ -0,0 +1,24 @@
+op {
+  graph_op_name: "StringToHashBucket"
+  out_arg {
+    name: "output"
+    description: <<END
+A Tensor of the same shape as the input `string_tensor`.
+END
+  }
+  attr {
+    name: "num_buckets"
+    description: <<END
+The number of buckets.
+END
+  }
+  summary: "Converts each string in the input Tensor to its hash mod by a number of buckets."
+  description: <<END
+The hash function is deterministic on the content of the string within the
+process.
+
+Note that the hash function may change from time to time.
+This functionality will be deprecated and it's recommended to use
+`tf.string_to_hash_bucket_fast()` or `tf.string_to_hash_bucket_strong()`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StringToHashBucketFast.pbtxt b/tensorflow/core/api_def/base_api/api_def_StringToHashBucketFast.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a68d54a53412fbd67866bd47e0583e935b7eb541
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StringToHashBucketFast.pbtxt
@@ -0,0 +1,30 @@
+op {
+  graph_op_name: "StringToHashBucketFast"
+  in_arg {
+    name: "input"
+    description: <<END
+The strings to assign a hash bucket.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A Tensor of the same shape as the input `string_tensor`.
+END
+  }
+  attr {
+    name: "num_buckets"
+    description: <<END
+The number of buckets.
+END
+  }
+  summary: "Converts each string in the input Tensor to its hash mod by a number of buckets."
+  description: <<END
+The hash function is deterministic on the content of the string within the
+process and will never change. However, it is not suitable for cryptography.
+This function may be used when CPU time is scarce and inputs are trusted or
+unimportant. There is a risk of adversaries constructing inputs that all hash
+to the same bucket. To prevent this problem, use a strong hash function with
+`tf.string_to_hash_bucket_strong`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StringToHashBucketStrong.pbtxt b/tensorflow/core/api_def/base_api/api_def_StringToHashBucketStrong.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b63fbd1ff9d9ab6d0701045d30887cea29f4e1a0
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StringToHashBucketStrong.pbtxt
@@ -0,0 +1,41 @@
+op {
+  graph_op_name: "StringToHashBucketStrong"
+  in_arg {
+    name: "input"
+    description: <<END
+The strings to assign a hash bucket.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A Tensor of the same shape as the input `string_tensor`.
+END
+  }
+  attr {
+    name: "num_buckets"
+    description: <<END
+The number of buckets.
+END
+  }
+  attr {
+    name: "key"
+    description: <<END
+The key for the keyed hash function passed as a list of two uint64
+elements.
+END
+  }
+  summary: "Converts each string in the input Tensor to its hash mod by a number of buckets."
+  description: <<END
+The hash function is deterministic on the content of the string within the
+process. The hash function is a keyed hash function, where attribute `key`
+defines the key of the hash function. `key` is an array of 2 elements.
+
+A strong hash is important when inputs may be malicious, e.g. URLs with
+additional components. Adversaries could try to make their inputs hash to the
+same bucket for a denial-of-service attack or to skew the results. A strong
+hash prevents this by making it difficult, if not infeasible, to compute inputs
+that hash to the same bucket. This comes at a cost of roughly 4x higher compute
+time than `tf.string_to_hash_bucket_fast`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_StringToNumber.pbtxt b/tensorflow/core/api_def/base_api/api_def_StringToNumber.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e6e0b1dc13d19bd9f77d52fc89080cb0e25c5274
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_StringToNumber.pbtxt
@@ -0,0 +1,20 @@
+op {
+  graph_op_name: "StringToNumber"
+  out_arg {
+    name: "output"
+    description: <<END
+A Tensor of the same shape as the input `string_tensor`.
+END
+  }
+  attr {
+    name: "out_type"
+    description: <<END
+The numeric type to interpret each string in `string_tensor` as.
+END
+  }
+  summary: "Converts each string in the input Tensor to the specified numeric type."
+  description: <<END
+(Note that int32 overflow results in an error while float overflow
+results in a rounded value.)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Sub.pbtxt b/tensorflow/core/api_def/base_api/api_def_Sub.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..73b82d6ac8f675af1802a72d8b9442d51e2c40fd
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Sub.pbtxt
@@ -0,0 +1,14 @@
+op {
+  graph_op_name: "Sub"
+  endpoint {
+    name: "Subtract"
+  }
+  endpoint {
+    name: "Sub"
+  }
+  summary: "Returns x - y element-wise."
+  description: <<END
+*NOTE*: `Sub` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Substr.pbtxt b/tensorflow/core/api_def/base_api/api_def_Substr.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8fc1e5cba39feb2066f2ee9f445c520e713a4792
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Substr.pbtxt
@@ -0,0 +1,103 @@
+op {
+  graph_op_name: "Substr"
+  in_arg {
+    name: "input"
+    description: <<END
+Tensor of strings
+END
+  }
+  in_arg {
+    name: "pos"
+    description: <<END
+Scalar defining the position of first character in each substring
+END
+  }
+  in_arg {
+    name: "len"
+    description: <<END
+Scalar defining the number of characters to include in each substring
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Tensor of substrings
+END
+  }
+  summary: "Return substrings from `Tensor` of strings."
+  description: <<END
+For each string in the input `Tensor`, creates a substring starting at index
+`pos` with a total length of `len`.
+
+If `len` defines a substring that would extend beyond the length of the input
+string, then as many characters as possible are used.
+
+If `pos` is negative or specifies a character index larger than any of the input
+strings, then an `InvalidArgumentError` is thrown.
+
+`pos` and `len` must have the same shape, otherwise a `ValueError` is thrown on
+Op creation.
+
+*NOTE*: `Substr` supports broadcasting up to two dimensions. More about
+broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+
+---
+
+Examples
+
+Using scalar `pos` and `len`:
+
+```python
+input = [b'Hello', b'World']
+position = 1
+length = 3
+
+output = [b'ell', b'orl']
+```
+
+Using `pos` and `len` with same shape as `input`:
+
+```python
+input = [[b'ten', b'eleven', b'twelve'],
+         [b'thirteen', b'fourteen', b'fifteen'],
+         [b'sixteen', b'seventeen', b'eighteen']]
+position = [[1, 2, 3],
+            [1, 2, 3],
+            [1, 2, 3]]
+length =   [[2, 3, 4],
+            [4, 3, 2],
+            [5, 5, 5]]
+
+output = [[b'en', b'eve', b'lve'],
+          [b'hirt', b'urt', b'te'],
+          [b'ixtee', b'vente', b'hteen']]
+```
+
+Broadcasting `pos` and `len` onto `input`:
+
+```
+input = [[b'ten', b'eleven', b'twelve'],
+         [b'thirteen', b'fourteen', b'fifteen'],
+         [b'sixteen', b'seventeen', b'eighteen'],
+         [b'nineteen', b'twenty', b'twentyone']]
+position = [1, 2, 3]
+length =   [1, 2, 3]
+
+output = [[b'e', b'ev', b'lve'],
+          [b'h', b'ur', b'tee'],
+          [b'i', b've', b'hte'],
+          [b'i', b'en', b'nty']]
+```
+
+Broadcasting `input` onto `pos` and `len`:
+
+```
+input = b'thirteen'
+position = [1, 5, 7]
+length =   [3, 2, 1]
+
+output = [b'hir', b'ee', b'n']
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Sum.pbtxt b/tensorflow/core/api_def/base_api/api_def_Sum.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..295d5b86c088fde919ffe643f4f7d45a094d1776
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Sum.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "Sum"
+  endpoint {
+    name: "Sum"
+  }
+  endpoint {
+    name: "ReduceSum"
+  }
+  in_arg {
+    name: "input"
+    description: <<END
+The tensor to reduce.
+END
+  }
+  in_arg {
+    name: "reduction_indices"
+    rename_to: "axis"
+    description: <<END
+The dimensions to reduce. Must be in the range
+`[-rank(input), rank(input))`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The reduced tensor.
+END
+  }
+  attr {
+    name: "keep_dims"
+    description: <<END
+If true, retain reduced dimensions with length 1.
+END
+  }
+  summary: "Computes the sum of elements across dimensions of a tensor."
+  description: <<END
+Reduces `input` along the dimensions given in `reduction_indices`. Unless
+`keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+`reduction_indices`. If `keep_dims` is true, the reduced dimensions are
+retained with length 1.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Svd.pbtxt b/tensorflow/core/api_def/base_api/api_def_Svd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3ec746a117a6a684c3a0d136ec9ce89ed948cae4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Svd.pbtxt
@@ -0,0 +1,62 @@
+op {
+  graph_op_name: "Svd"
+  in_arg {
+    name: "input"
+    description: <<END
+A tensor of shape `[..., M, N]` whose inner-most 2 dimensions
+form matrices of size `[M, N]`. Let `P` be the minimum of `M` and `N`.
+END
+  }
+  out_arg {
+    name: "s"
+    description: <<END
+Singular values. Shape is `[..., P]`.
+END
+  }
+  out_arg {
+    name: "u"
+    description: <<END
+Left singular vectors. If `full_matrices` is `False` then shape is
+`[..., M, P]`; if `full_matrices` is `True` then shape is
+`[..., M, M]`. Undefined if `compute_uv` is `False`.
+END
+  }
+  out_arg {
+    name: "v"
+    description: <<END
+Left singular vectors. If `full_matrices` is `False` then shape is
+`[..., N, P]`. If `full_matrices` is `True` then shape is `[..., N, N]`.
+Undefined if `compute_uv` is false.
+END
+  }
+  attr {
+    name: "compute_uv"
+    description: <<END
+If true, left and right singular vectors will be
+computed and returned in `u` and `v`, respectively.
+If false, `u` and `v` are not set and should never referenced.
+END
+  }
+  attr {
+    name: "full_matrices"
+    description: <<END
+If true, compute full-sized `u` and `v`. If false
+(the default), compute only the leading `P` singular vectors.
+Ignored if `compute_uv` is `False`.
+END
+  }
+  summary: "Computes the singular value decompositions of one or more matrices."
+  description: <<END
+Computes the SVD of each inner matrix in `input` such that
+`input[..., :, :] = u[..., :, :] * diag(s[..., :, :]) * transpose(v[..., :, :])`
+
+```python
+# a is a tensor containing a batch of matrices.
+# s is a tensor of singular values for each matrix.
+# u is the tensor containing of left singular vectors for each matrix.
+# v is the tensor containing of right singular vectors for each matrix.
+s, u, v = svd(a)
+s, _, _ = svd(a, compute_uv=False)
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Switch.pbtxt b/tensorflow/core/api_def/base_api/api_def_Switch.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5b9206df74290b17caeec4e63c21abe988930b6c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Switch.pbtxt
@@ -0,0 +1,34 @@
+op {
+  graph_op_name: "Switch"
+  in_arg {
+    name: "data"
+    description: <<END
+The tensor to be forwarded to the appropriate output.
+END
+  }
+  in_arg {
+    name: "pred"
+    description: <<END
+A scalar that specifies which output port will receive data.
+END
+  }
+  out_arg {
+    name: "output_false"
+    description: <<END
+If `pred` is false, data will be forwarded to this output.
+END
+  }
+  out_arg {
+    name: "output_true"
+    description: <<END
+If `pred` is true, data will be forwarded to this output.
+END
+  }
+  summary: "Forwards `data` to the output port determined by `pred`."
+  description: <<END
+If `pred` is true, the `data` input is forwarded to `output_true`. Otherwise,
+the data goes to `output_false`.
+
+See also `RefSwitch` and `Merge`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_SymbolicGradient.pbtxt b/tensorflow/core/api_def/base_api/api_def_SymbolicGradient.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b5cb6dbc122aac2d2c77299b3f136ed8aae2efe9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_SymbolicGradient.pbtxt
@@ -0,0 +1,51 @@
+op {
+  graph_op_name: "SymbolicGradient"
+  in_arg {
+    name: "input"
+    description: <<END
+a list of input tensors of size N + M;
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+a list of output tensors of size N;
+END
+  }
+  attr {
+    name: "Tin"
+    description: <<END
+the type list for the input list.
+END
+  }
+  attr {
+    name: "Tout"
+    description: <<END
+the type list for the input list.
+END
+  }
+  attr {
+    name: "f"
+    description: <<END
+The function we want to compute the gradient for.
+
+The function 'f' must be a numerical function which takes N inputs and
+produces M outputs. Its gradient function 'g', which is computed by
+this SymbolicGradient op is a function taking N + M inputs and
+produces N outputs.
+
+I.e. if we have
+   (y1, y2, ..., y_M) = f(x1, x2, ..., x_N),
+then, g is
+   (dL/dx1, dL/dx2, ..., dL/dx_N) = g(x1, x2, ..., x_N,
+                                     dL/dy1, dL/dy2, ..., dL/dy_M),
+
+where L is a scalar-value function of (x1, x2, ..., xN) (e.g., the
+loss function). dL/dx_i is the partial derivative of L with respect
+to x_i.
+
+(Needs some math expert to say the comment above better.)
+END
+  }
+  summary: "Computes the gradient function for function f via backpropagation."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_T.pbtxt b/tensorflow/core/api_def/base_api/api_def_T.pbtxt
deleted file mode 100644
index 8d1cbbcc066aee477e7eb1a39b6d8cddf84e05a0..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_T.pbtxt
+++ /dev/null
@@ -1,619 +0,0 @@
-op {
-  graph_op_name: "TFRecordDataset"
-  endpoint {
-    name: "TFRecordDataset"
-  }
-  summary: "Creates a dataset that emits the records from one or more TFRecord files."
-}
-op {
-  graph_op_name: "TFRecordReader"
-  endpoint {
-    name: "TFRecordReader"
-  }
-  summary: "A Reader that outputs the records from a TensorFlow Records file."
-}
-op {
-  graph_op_name: "TFRecordReaderV2"
-  endpoint {
-    name: "TFRecordReaderV2"
-  }
-  summary: "A Reader that outputs the records from a TensorFlow Records file."
-}
-op {
-  graph_op_name: "TakeDataset"
-  endpoint {
-    name: "TakeDataset"
-  }
-  summary: "Creates a dataset that contains `count` elements from the `input_dataset`."
-}
-op {
-  graph_op_name: "TakeManySparseFromTensorsMap"
-  endpoint {
-    name: "TakeManySparseFromTensorsMap"
-  }
-  summary: "Read `SparseTensors` from a `SparseTensorsMap` and concatenate them."
-  description: <<END
-The input `sparse_handles` must be an `int64` matrix of shape `[N, 1]` where
-`N` is the minibatch size and the rows correspond to the output handles of
-`AddSparseToTensorsMap` or `AddManySparseToTensorsMap`.  The ranks of the
-original `SparseTensor` objects that went into the given input ops must all
-match.  When the final `SparseTensor` is created, it has rank one
-higher than the ranks of the incoming `SparseTensor` objects
-(they have been concatenated along a new row dimension on the left).
-
-The output `SparseTensor` object's shape values for all dimensions but the
-first are the max across the input `SparseTensor` objects' shape values
-for the corresponding dimensions.  Its first shape value is `N`, the minibatch
-size.
-
-The input `SparseTensor` objects' indices are assumed ordered in
-standard lexicographic order.  If this is not the case, after this
-step run `SparseReorder` to restore index ordering.
-
-For example, if the handles represent an input, which is a `[2, 3]` matrix
-representing two original `SparseTensor` objects:
-
-```
-    index = [ 0]
-            [10]
-            [20]
-    values = [1, 2, 3]
-    shape = [50]
-```
-
-and
-
-```
-    index = [ 2]
-            [10]
-    values = [4, 5]
-    shape = [30]
-```
-
-then the final `SparseTensor` will be:
-
-```
-    index = [0  0]
-            [0 10]
-            [0 20]
-            [1  2]
-            [1 10]
-    values = [1, 2, 3, 4, 5]
-    shape = [2 50]
-```
-END
-}
-op {
-  graph_op_name: "Tan"
-  endpoint {
-    name: "Tan"
-  }
-  summary: "Computes tan of x element-wise."
-}
-op {
-  graph_op_name: "Tanh"
-  endpoint {
-    name: "Tanh"
-  }
-  summary: "Computes hyperbolic tangent of `x` element-wise."
-}
-op {
-  graph_op_name: "TanhGrad"
-  endpoint {
-    name: "TanhGrad"
-  }
-  summary: "Computes the gradient for the tanh of `x` wrt its input."
-  description: <<END
-Specifically, `grad = dy * (1 - y*y)`, where `y = tanh(x)`, and `dy`
-is the corresponding input gradient.
-END
-}
-op {
-  graph_op_name: "TemporaryVariable"
-  endpoint {
-    name: "TemporaryVariable"
-  }
-  summary: "Returns a tensor that may be mutated, but only persists within a single step."
-  description: <<END
-This is an experimental op for internal use only and it is possible to use this
-op in unsafe ways.  DO NOT USE unless you fully understand the risks.
-
-It is the caller's responsibility to ensure that 'ref' is eventually passed to a
-matching 'DestroyTemporaryVariable' op after all other uses have completed.
-
-Outputs a ref to the tensor state so it may be read or modified.
-
-  E.g.
-      var = state_ops._temporary_variable([1, 2], types.float_)
-      var_name = var.op.name
-      var = state_ops.assign(var, [[4.0, 5.0]])
-      var = state_ops.assign_add(var, [[6.0, 7.0]])
-      final = state_ops._destroy_temporary_variable(var, var_name=var_name)
-END
-}
-op {
-  graph_op_name: "TensorArray"
-  endpoint {
-    name: "TensorArray"
-  }
-}
-op {
-  graph_op_name: "TensorArrayClose"
-  endpoint {
-    name: "TensorArrayClose"
-  }
-}
-op {
-  graph_op_name: "TensorArrayCloseV2"
-  endpoint {
-    name: "TensorArrayCloseV2"
-  }
-  summary: "Deprecated. Use TensorArrayCloseV3"
-}
-op {
-  graph_op_name: "TensorArrayCloseV3"
-  endpoint {
-    name: "TensorArrayCloseV3"
-  }
-  summary: "Delete the TensorArray from its resource container."
-  description: <<END
-This enables the user to close and release the resource in the middle
-of a step/run.
-END
-}
-op {
-  graph_op_name: "TensorArrayConcat"
-  endpoint {
-    name: "TensorArrayConcat"
-  }
-}
-op {
-  graph_op_name: "TensorArrayConcatV2"
-  endpoint {
-    name: "TensorArrayConcatV2"
-  }
-  summary: "Deprecated. Use TensorArrayConcatV3"
-}
-op {
-  graph_op_name: "TensorArrayConcatV3"
-  endpoint {
-    name: "TensorArrayConcatV3"
-  }
-  summary: "Concat the elements from the TensorArray into value `value`."
-  description: <<END
-Takes `T` elements of shapes
-
-  ```
-  (n0 x d0 x d1 x ...), (n1 x d0 x d1 x ...), ..., (n(T-1) x d0 x d1 x ...)
-  ```
-
-and concatenates them into a Tensor of shape:
-
-  ```(n0 + n1 + ... + n(T-1) x d0 x d1 x ...)```
-
-All elements must have the same shape (excepting the first dimension).
-END
-}
-op {
-  graph_op_name: "TensorArrayGather"
-  endpoint {
-    name: "TensorArrayGather"
-  }
-}
-op {
-  graph_op_name: "TensorArrayGatherV2"
-  endpoint {
-    name: "TensorArrayGatherV2"
-  }
-  summary: "Deprecated. Use TensorArrayGatherV3"
-}
-op {
-  graph_op_name: "TensorArrayGatherV3"
-  endpoint {
-    name: "TensorArrayGatherV3"
-  }
-  summary: "Gather specific elements from the TensorArray into output `value`."
-  description: <<END
-All elements selected by `indices` must have the same shape.
-END
-}
-op {
-  graph_op_name: "TensorArrayGrad"
-  endpoint {
-    name: "TensorArrayGrad"
-  }
-}
-op {
-  graph_op_name: "TensorArrayGradV2"
-  endpoint {
-    name: "TensorArrayGradV2"
-  }
-  summary: "Deprecated. Use TensorArrayGradV3"
-}
-op {
-  graph_op_name: "TensorArrayGradV3"
-  endpoint {
-    name: "TensorArrayGradV3"
-  }
-  summary: "Creates a TensorArray for storing the gradients of values in the given handle."
-  description: <<END
-If the given TensorArray gradient already exists, returns a reference to it.
-
-Locks the size of the original TensorArray by disabling its dynamic size flag.
-
-**A note about the input flow_in:**
-
-The handle flow_in forces the execution of the gradient lookup to occur
-only after certain other operations have occurred.  For example, when
-the forward TensorArray is dynamically sized, writes to this TensorArray
-may resize the object.  The gradient TensorArray is statically sized based
-on the size of the forward TensorArray when this operation executes.
-Furthermore, the size of the forward TensorArray is frozen by this call.
-As a result, the flow is used to ensure that the call to generate the gradient
-TensorArray only happens after all writes are executed.
-
-In the case of dynamically sized TensorArrays, gradient computation should
-only be performed on read operations that have themselves been chained via
-flow to occur only after all writes have executed. That way the final size
-of the forward TensorArray is known when this operation is called.
-
-**A note about the source attribute:**
-
-TensorArray gradient calls use an accumulator TensorArray object.  If
-multiple gradients are calculated and run in the same session, the multiple
-gradient nodes may accidentally flow through the same accumulator TensorArray.
-This double counts and generally breaks the TensorArray gradient flow.
-
-The solution is to identify which gradient call this particular
-TensorArray gradient is being called in.  This is performed by identifying
-a unique string (e.g. "gradients", "gradients_1", ...) from the input
-gradient Tensor's name.  This string is used as a suffix when creating
-the TensorArray gradient object here (the attribute `source`).
-
-The attribute `source` is added as a suffix to the forward TensorArray's
-name when performing the creation / lookup, so that each separate gradient
-calculation gets its own TensorArray accumulator.
-END
-}
-op {
-  graph_op_name: "TensorArrayPack"
-  endpoint {
-    name: "TensorArrayPack"
-  }
-}
-op {
-  graph_op_name: "TensorArrayRead"
-  endpoint {
-    name: "TensorArrayRead"
-  }
-}
-op {
-  graph_op_name: "TensorArrayReadV2"
-  endpoint {
-    name: "TensorArrayReadV2"
-  }
-  summary: "Deprecated. Use TensorArrayReadV3"
-}
-op {
-  graph_op_name: "TensorArrayReadV3"
-  endpoint {
-    name: "TensorArrayReadV3"
-  }
-  summary: "Read an element from the TensorArray into output `value`."
-}
-op {
-  graph_op_name: "TensorArrayScatter"
-  endpoint {
-    name: "TensorArrayScatter"
-  }
-}
-op {
-  graph_op_name: "TensorArrayScatterV2"
-  endpoint {
-    name: "TensorArrayScatterV2"
-  }
-  summary: "Deprecated. Use TensorArrayScatterV3"
-}
-op {
-  graph_op_name: "TensorArrayScatterV3"
-  endpoint {
-    name: "TensorArrayScatterV3"
-  }
-  summary: "Scatter the data from the input value into specific TensorArray elements."
-  description: <<END
-`indices` must be a vector, its length must match the first dim of `value`.
-END
-}
-op {
-  graph_op_name: "TensorArraySize"
-  endpoint {
-    name: "TensorArraySize"
-  }
-}
-op {
-  graph_op_name: "TensorArraySizeV2"
-  endpoint {
-    name: "TensorArraySizeV2"
-  }
-  summary: "Deprecated. Use TensorArraySizeV3"
-}
-op {
-  graph_op_name: "TensorArraySizeV3"
-  endpoint {
-    name: "TensorArraySizeV3"
-  }
-  summary: "Get the current size of the TensorArray."
-}
-op {
-  graph_op_name: "TensorArraySplit"
-  endpoint {
-    name: "TensorArraySplit"
-  }
-}
-op {
-  graph_op_name: "TensorArraySplitV2"
-  endpoint {
-    name: "TensorArraySplitV2"
-  }
-  summary: "Deprecated. Use TensorArraySplitV3"
-}
-op {
-  graph_op_name: "TensorArraySplitV3"
-  endpoint {
-    name: "TensorArraySplitV3"
-  }
-  summary: "Split the data from the input value into TensorArray elements."
-  description: <<END
-Assuming that `lengths` takes on values
-
-  ```(n0, n1, ..., n(T-1))```
-
-and that `value` has shape
-
-  ```(n0 + n1 + ... + n(T-1) x d0 x d1 x ...)```,
-
-this splits values into a TensorArray with T tensors.
-
-TensorArray index t will be the subtensor of values with starting position
-
-  ```(n0 + n1 + ... + n(t-1), 0, 0, ...)```
-
-and having size
-
-  ```nt x d0 x d1 x ...```
-END
-}
-op {
-  graph_op_name: "TensorArrayUnpack"
-  endpoint {
-    name: "TensorArrayUnpack"
-  }
-}
-op {
-  graph_op_name: "TensorArrayV2"
-  endpoint {
-    name: "TensorArrayV2"
-  }
-  summary: "Deprecated. Use TensorArrayV3"
-}
-op {
-  graph_op_name: "TensorArrayV3"
-  endpoint {
-    name: "TensorArrayV3"
-  }
-  summary: "An array of Tensors of given size."
-  description: <<END
-Write data via Write and read via Read or Pack.
-END
-}
-op {
-  graph_op_name: "TensorArrayWrite"
-  endpoint {
-    name: "TensorArrayWrite"
-  }
-}
-op {
-  graph_op_name: "TensorArrayWriteV2"
-  endpoint {
-    name: "TensorArrayWriteV2"
-  }
-  summary: "Deprecated. Use TensorArrayGradV3"
-}
-op {
-  graph_op_name: "TensorArrayWriteV3"
-  endpoint {
-    name: "TensorArrayWriteV3"
-  }
-  summary: "Push an element onto the tensor_array."
-}
-op {
-  graph_op_name: "TensorDataset"
-  endpoint {
-    name: "TensorDataset"
-  }
-  summary: "Creates a dataset that emits `components` as a tuple of tensors once."
-}
-op {
-  graph_op_name: "TensorSliceDataset"
-  endpoint {
-    name: "TensorSliceDataset"
-  }
-  summary: "Creates a dataset that emits each dim-0 slice of `components` once."
-}
-op {
-  graph_op_name: "TensorSummary"
-  endpoint {
-    name: "TensorSummary"
-  }
-  summary: "Outputs a `Summary` protocol buffer with a tensor."
-  description: <<END
-This op is being phased out in favor of TensorSummaryV2, which lets callers pass
-a tag as well as a serialized SummaryMetadata proto string that contains
-plugin-specific data. We will keep this op to maintain backwards compatibility.
-END
-}
-op {
-  graph_op_name: "TensorSummaryV2"
-  endpoint {
-    name: "TensorSummaryV2"
-  }
-  summary: "Outputs a `Summary` protocol buffer with a tensor and per-plugin data."
-}
-op {
-  graph_op_name: "TextLineDataset"
-  endpoint {
-    name: "TextLineDataset"
-  }
-  summary: "Creates a dataset that emits the lines of one or more text files."
-}
-op {
-  graph_op_name: "TextLineReader"
-  endpoint {
-    name: "TextLineReader"
-  }
-  summary: "A Reader that outputs the lines of a file delimited by \'\\n\'."
-}
-op {
-  graph_op_name: "TextLineReaderV2"
-  endpoint {
-    name: "TextLineReaderV2"
-  }
-  summary: "A Reader that outputs the lines of a file delimited by \'\\n\'."
-}
-op {
-  graph_op_name: "ThreadUnsafeUnigramCandidateSampler"
-  endpoint {
-    name: "ThreadUnsafeUnigramCandidateSampler"
-  }
-  summary: "Generates labels for candidate sampling with a learned unigram distribution."
-  description: <<END
-See explanations of candidate sampling and the data formats at
-go/candidate-sampling.
-
-For each batch, this op picks a single set of sampled candidate labels.
-
-The advantages of sampling candidates per-batch are simplicity and the
-possibility of efficient dense matrix multiplication. The disadvantage is that
-the sampled candidates must be chosen independently of the context and of the
-true labels.
-END
-}
-op {
-  graph_op_name: "Tile"
-  endpoint {
-    name: "Tile"
-  }
-  summary: "Constructs a tensor by tiling a given tensor."
-  description: <<END
-This operation creates a new tensor by replicating `input` `multiples` times.
-The output tensor's i'th dimension has `input.dims(i) * multiples[i]` elements,
-and the values of `input` are replicated `multiples[i]` times along the 'i'th
-dimension. For example, tiling `[a b c d]` by `[2]` produces
-`[a b c d a b c d]`.
-END
-}
-op {
-  graph_op_name: "TileGrad"
-  endpoint {
-    name: "TileGrad"
-  }
-  summary: "Returns the gradient of `Tile`."
-  description: <<END
-Since `Tile` takes an input and repeats the input `multiples` times
-along each dimension, `TileGrad` takes in `multiples` and aggregates
-each repeated tile of `input` into `output`.
-END
-}
-op {
-  graph_op_name: "TopK"
-  endpoint {
-    name: "TopK"
-  }
-  summary: "Finds values and indices of the `k` largest elements for the last dimension."
-  description: <<END
-If the input is a vector (rank-1), finds the `k` largest entries in the vector
-and outputs their values and indices as vectors.  Thus `values[j]` is the
-`j`-th largest entry in `input`, and its index is `indices[j]`.
-
-For matrices (resp. higher rank input), computes the top `k` entries in each
-row (resp. vector along the last dimension).  Thus,
-
-    values.shape = indices.shape = input.shape[:-1] + [k]
-
-If two elements are equal, the lower-index element appears first.
-
-If `k` varies dynamically, use `TopKV2` below.
-END
-}
-op {
-  graph_op_name: "TopKV2"
-  endpoint {
-    name: "TopKV2"
-  }
-  summary: "Finds values and indices of the `k` largest elements for the last dimension."
-  description: <<END
-If the input is a vector (rank-1), finds the `k` largest entries in the vector
-and outputs their values and indices as vectors.  Thus `values[j]` is the
-`j`-th largest entry in `input`, and its index is `indices[j]`.
-
-For matrices (resp. higher rank input), computes the top `k` entries in each
-row (resp. vector along the last dimension).  Thus,
-
-    values.shape = indices.shape = input.shape[:-1] + [k]
-
-If two elements are equal, the lower-index element appears first.
-END
-}
-op {
-  graph_op_name: "Transpose"
-  endpoint {
-    name: "Transpose"
-  }
-  summary: "Shuffle dimensions of x according to a permutation."
-  description: <<END
-The output `y` has the same rank as `x`. The shapes of `x` and `y` satisfy:
-  `y.shape[i] == x.shape[perm[i]] for i in [0, 1, ..., rank(x) - 1]`
-END
-}
-op {
-  graph_op_name: "TruncateDiv"
-  endpoint {
-    name: "TruncateDiv"
-  }
-  summary: "Returns x / y element-wise for integer types."
-  description: <<END
-Truncation designates that negative numbers will round fractional quantities
-toward zero. I.e. -7 / 5 = 1. This matches C semantics but it is different
-than Python semantics. See `FloorDiv` for a division function that matches
-Python Semantics.
-
-*NOTE*: `TruncateDiv` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "TruncateMod"
-  endpoint {
-    name: "TruncateMod"
-  }
-  summary: "Returns element-wise remainder of division. This emulates C semantics in that"
-  description: <<END
-the result here is consistent with a truncating divide. E.g. `truncate(x / y) *
-y + truncate_mod(x, y) = x`.
-
-*NOTE*: `TruncateMod` supports broadcasting. More about broadcasting
-[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-END
-}
-op {
-  graph_op_name: "TruncatedNormal"
-  endpoint {
-    name: "TruncatedNormal"
-  }
-  summary: "Outputs random values from a truncated normal distribution."
-  description: <<END
-The generated values follow a normal distribution with mean 0 and standard
-deviation 1, except that values whose magnitude is more than 2 standard
-deviations from the mean are dropped and re-picked.
-END
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_TFRecordDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_TFRecordDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..80f64cebb1bef262146afdadd5c37b0a30277db0
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TFRecordDataset.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "TFRecordDataset"
+  in_arg {
+    name: "filenames"
+    description: <<END
+A scalar or vector containing the name(s) of the file(s) to be
+read.
+END
+  }
+  in_arg {
+    name: "compression_type"
+    description: <<END
+A scalar containing either (i) the empty string (no
+compression), (ii) "ZLIB", or (iii) "GZIP".
+END
+  }
+  in_arg {
+    name: "buffer_size"
+    description: <<END
+A scalar representing the number of bytes to buffer. A value of
+0 means no buffering will be performed.
+END
+  }
+  summary: "Creates a dataset that emits the records from one or more TFRecord files."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TFRecordReader.pbtxt b/tensorflow/core/api_def/base_api/api_def_TFRecordReader.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..100e3467530cd9a9234afa14c3c726b912f8998f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TFRecordReader.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "TFRecordReader"
+  visibility: SKIP
+  out_arg {
+    name: "reader_handle"
+    description: <<END
+The handle to reference the Reader.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this reader is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this reader is named in the given bucket
+with this shared_name. Otherwise, the node name is used instead.
+END
+  }
+  summary: "A Reader that outputs the records from a TensorFlow Records file."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TFRecordReaderV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_TFRecordReaderV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f12ebe54effeb0b86b25cbacddd3379c65c1a058
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TFRecordReaderV2.pbtxt
@@ -0,0 +1,27 @@
+op {
+  graph_op_name: "TFRecordReaderV2"
+  endpoint {
+    name: "TFRecordReader"
+  }
+  out_arg {
+    name: "reader_handle"
+    description: <<END
+The handle to reference the Reader.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this reader is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this reader is named in the given bucket
+with this shared_name. Otherwise, the node name is used instead.
+END
+  }
+  summary: "A Reader that outputs the records from a TensorFlow Records file."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TakeDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_TakeDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8808dc6b1f0d0ae3a0e83f376eab245beaad2de1
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TakeDataset.pbtxt
@@ -0,0 +1,12 @@
+op {
+  graph_op_name: "TakeDataset"
+  in_arg {
+    name: "count"
+    description: <<END
+A scalar representing the number of elements from the `input_dataset`
+that should be taken. A value of `-1` indicates that all of `input_dataset`
+is taken.
+END
+  }
+  summary: "Creates a dataset that contains `count` elements from the `input_dataset`."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TakeManySparseFromTensorsMap.pbtxt b/tensorflow/core/api_def/base_api/api_def_TakeManySparseFromTensorsMap.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2073d7245140a666f0fe2ea5d0aa4b31ed775ef4
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TakeManySparseFromTensorsMap.pbtxt
@@ -0,0 +1,100 @@
+op {
+  graph_op_name: "TakeManySparseFromTensorsMap"
+  in_arg {
+    name: "sparse_handles"
+    description: <<END
+1-D, The `N` serialized `SparseTensor` objects.
+Shape: `[N]`.
+END
+  }
+  out_arg {
+    name: "sparse_indices"
+    description: <<END
+2-D.  The `indices` of the minibatch `SparseTensor`.
+END
+  }
+  out_arg {
+    name: "sparse_values"
+    description: <<END
+1-D.  The `values` of the minibatch `SparseTensor`.
+END
+  }
+  out_arg {
+    name: "sparse_shape"
+    description: <<END
+1-D.  The `shape` of the minibatch `SparseTensor`.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The `dtype` of the `SparseTensor` objects stored in the
+`SparseTensorsMap`.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+The container name for the `SparseTensorsMap` read by this op.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+The shared name for the `SparseTensorsMap` read by this op.
+It should not be blank; rather the `shared_name` or unique Operation name
+of the Op that created the original `SparseTensorsMap` should be used.
+END
+  }
+  summary: "Read `SparseTensors` from a `SparseTensorsMap` and concatenate them."
+  description: <<END
+The input `sparse_handles` must be an `int64` matrix of shape `[N, 1]` where
+`N` is the minibatch size and the rows correspond to the output handles of
+`AddSparseToTensorsMap` or `AddManySparseToTensorsMap`.  The ranks of the
+original `SparseTensor` objects that went into the given input ops must all
+match.  When the final `SparseTensor` is created, it has rank one
+higher than the ranks of the incoming `SparseTensor` objects
+(they have been concatenated along a new row dimension on the left).
+
+The output `SparseTensor` object's shape values for all dimensions but the
+first are the max across the input `SparseTensor` objects' shape values
+for the corresponding dimensions.  Its first shape value is `N`, the minibatch
+size.
+
+The input `SparseTensor` objects' indices are assumed ordered in
+standard lexicographic order.  If this is not the case, after this
+step run `SparseReorder` to restore index ordering.
+
+For example, if the handles represent an input, which is a `[2, 3]` matrix
+representing two original `SparseTensor` objects:
+
+```
+    index = [ 0]
+            [10]
+            [20]
+    values = [1, 2, 3]
+    shape = [50]
+```
+
+and
+
+```
+    index = [ 2]
+            [10]
+    values = [4, 5]
+    shape = [30]
+```
+
+then the final `SparseTensor` will be:
+
+```
+    index = [0  0]
+            [0 10]
+            [0 20]
+            [1  2]
+            [1 10]
+    values = [1, 2, 3, 4, 5]
+    shape = [2 50]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Tan.pbtxt b/tensorflow/core/api_def/base_api/api_def_Tan.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..20f3e4eab3d175de7467f033f6f4b73089a824b2
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Tan.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Tan"
+  summary: "Computes tan of x element-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Tanh.pbtxt b/tensorflow/core/api_def/base_api/api_def_Tanh.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3658ee641a71d471c4b8a203017dd385346292d9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Tanh.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Tanh"
+  summary: "Computes hyperbolic tangent of `x` element-wise."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TanhGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_TanhGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ef71385a2db66d23a53a4853b2807f1b575a500c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TanhGrad.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "TanhGrad"
+  visibility: HIDDEN
+  summary: "Computes the gradient for the tanh of `x` wrt its input."
+  description: <<END
+Specifically, `grad = dy * (1 - y*y)`, where `y = tanh(x)`, and `dy`
+is the corresponding input gradient.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TemporaryVariable.pbtxt b/tensorflow/core/api_def/base_api/api_def_TemporaryVariable.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3a41f69aa24f89121c48b9e8c5c530ccb296a8e9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TemporaryVariable.pbtxt
@@ -0,0 +1,45 @@
+op {
+  graph_op_name: "TemporaryVariable"
+  out_arg {
+    name: "ref"
+    description: <<END
+A reference to the variable tensor.
+END
+  }
+  attr {
+    name: "shape"
+    description: <<END
+The shape of the variable tensor.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of elements in the variable tensor.
+END
+  }
+  attr {
+    name: "var_name"
+    description: <<END
+Overrides the name used for the temporary variable resource. Default
+value is the name of the 'TemporaryVariable' op (which is guaranteed unique).
+END
+  }
+  summary: "Returns a tensor that may be mutated, but only persists within a single step."
+  description: <<END
+This is an experimental op for internal use only and it is possible to use this
+op in unsafe ways.  DO NOT USE unless you fully understand the risks.
+
+It is the caller's responsibility to ensure that 'ref' is eventually passed to a
+matching 'DestroyTemporaryVariable' op after all other uses have completed.
+
+Outputs a ref to the tensor state so it may be read or modified.
+
+  E.g.
+      var = state_ops._temporary_variable([1, 2], types.float_)
+      var_name = var.op.name
+      var = state_ops.assign(var, [[4.0, 5.0]])
+      var = state_ops.assign_add(var, [[6.0, 7.0]])
+      final = state_ops._destroy_temporary_variable(var, var_name=var_name)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArray.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArray.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7eaa468130a120f21c2a0f5578b5eb512bd72894
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArray.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "TensorArray"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayClose.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayClose.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e866250d3ab3a506164824bcb339fe87b6b160a8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayClose.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "TensorArrayClose"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayCloseV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayCloseV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ec784c94fb7802d3ceb0ed0b7a6470b5636d5fac
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayCloseV2.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "TensorArrayCloseV2"
+  visibility: SKIP
+  summary: "Deprecated. Use TensorArrayCloseV3"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayCloseV3.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayCloseV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4e469e4c07b9f3948e221c0efb0c8e33106ed6cc
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayCloseV3.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "TensorArrayCloseV3"
+  endpoint {
+    name: "TensorArrayClose"
+  }
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a TensorArray (output of TensorArray or TensorArrayGrad).
+END
+  }
+  summary: "Delete the TensorArray from its resource container."
+  description: <<END
+This enables the user to close and release the resource in the middle
+of a step/run.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayConcat.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayConcat.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e72b58de1c0aec0adddc27c955f3b3b4e2b5cc2d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayConcat.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "TensorArrayConcat"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayConcatV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayConcatV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..289b1ba3870c4b3e3715ed0d1107fc06be173032
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayConcatV2.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "TensorArrayConcatV2"
+  visibility: SKIP
+  summary: "Deprecated. Use TensorArrayConcatV3"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayConcatV3.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayConcatV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..502323b277aa6c66c87f3cfff1ecbbbdea9f7a90
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayConcatV3.pbtxt
@@ -0,0 +1,62 @@
+op {
+  graph_op_name: "TensorArrayConcatV3"
+  endpoint {
+    name: "TensorArrayConcat"
+  }
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a TensorArray.
+END
+  }
+  in_arg {
+    name: "flow_in"
+    description: <<END
+A float scalar that enforces proper chaining of operations.
+END
+  }
+  out_arg {
+    name: "value"
+    description: <<END
+All of the elements in the TensorArray, concatenated along the first
+axis.
+END
+  }
+  out_arg {
+    name: "lengths"
+    description: <<END
+A vector of the row sizes of the original T elements in the
+value output.  In the example above, this would be the values:
+`(n1, n2, ..., n(T-1))`.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of the elem that is returned.
+END
+  }
+  attr {
+    name: "element_shape_except0"
+    description: <<END
+The expected shape of an element, if known,
+excluding the first dimension. Used to validate the shapes of
+TensorArray elements. If this shape is not fully specified, concatenating
+zero-size TensorArrays is an error.
+END
+  }
+  summary: "Concat the elements from the TensorArray into value `value`."
+  description: <<END
+Takes `T` elements of shapes
+
+  ```
+  (n0 x d0 x d1 x ...), (n1 x d0 x d1 x ...), ..., (n(T-1) x d0 x d1 x ...)
+  ```
+
+and concatenates them into a Tensor of shape:
+
+  ```(n0 + n1 + ... + n(T-1) x d0 x d1 x ...)```
+
+All elements must have the same shape (excepting the first dimension).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayGather.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayGather.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d4d179874f6abbc76ab779c58bbc56f018981c94
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayGather.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "TensorArrayGather"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayGatherV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayGatherV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..df178020260437b5846241c08b8c93d5ab2fc097
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayGatherV2.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "TensorArrayGatherV2"
+  visibility: SKIP
+  summary: "Deprecated. Use TensorArrayGatherV3"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayGatherV3.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayGatherV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..44b4cd8143ff253c90904655e18d732003a72c02
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayGatherV3.pbtxt
@@ -0,0 +1,49 @@
+op {
+  graph_op_name: "TensorArrayGatherV3"
+  endpoint {
+    name: "TensorArrayGather"
+  }
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a TensorArray.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+The locations in the TensorArray from which to read tensor elements.
+END
+  }
+  in_arg {
+    name: "flow_in"
+    description: <<END
+A float scalar that enforces proper chaining of operations.
+END
+  }
+  out_arg {
+    name: "value"
+    description: <<END
+All of the elements in the TensorArray, concatenated along a new
+axis (the new dimension 0).
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of the elem that is returned.
+END
+  }
+  attr {
+    name: "element_shape"
+    description: <<END
+The expected shape of an element, if known. Used to
+validate the shapes of TensorArray elements. If this shape is not
+fully specified, gathering zero-size TensorArrays is an error.
+END
+  }
+  summary: "Gather specific elements from the TensorArray into output `value`."
+  description: <<END
+All elements selected by `indices` must have the same shape.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..517461edba243d709c663768a2223bcedb320afe
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayGrad.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "TensorArrayGrad"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayGradV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayGradV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..846aa705dbb0e664cb123038575f571de736ac8e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayGradV2.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "TensorArrayGradV2"
+  visibility: SKIP
+  summary: "Deprecated. Use TensorArrayGradV3"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayGradV3.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayGradV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..60634a0c8e7ab5f77805b65644c9ad78279cc70a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayGradV3.pbtxt
@@ -0,0 +1,64 @@
+op {
+  graph_op_name: "TensorArrayGradV3"
+  endpoint {
+    name: "TensorArrayGrad"
+  }
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to the forward TensorArray.
+END
+  }
+  in_arg {
+    name: "flow_in"
+    description: <<END
+A float scalar that enforces proper chaining of operations.
+END
+  }
+  attr {
+    name: "source"
+    description: <<END
+The gradient source string, used to decide which gradient TensorArray
+to return.
+END
+  }
+  summary: "Creates a TensorArray for storing the gradients of values in the given handle."
+  description: <<END
+If the given TensorArray gradient already exists, returns a reference to it.
+
+Locks the size of the original TensorArray by disabling its dynamic size flag.
+
+**A note about the input flow_in:**
+
+The handle flow_in forces the execution of the gradient lookup to occur
+only after certain other operations have occurred.  For example, when
+the forward TensorArray is dynamically sized, writes to this TensorArray
+may resize the object.  The gradient TensorArray is statically sized based
+on the size of the forward TensorArray when this operation executes.
+Furthermore, the size of the forward TensorArray is frozen by this call.
+As a result, the flow is used to ensure that the call to generate the gradient
+TensorArray only happens after all writes are executed.
+
+In the case of dynamically sized TensorArrays, gradient computation should
+only be performed on read operations that have themselves been chained via
+flow to occur only after all writes have executed. That way the final size
+of the forward TensorArray is known when this operation is called.
+
+**A note about the source attribute:**
+
+TensorArray gradient calls use an accumulator TensorArray object.  If
+multiple gradients are calculated and run in the same session, the multiple
+gradient nodes may accidentally flow through the same accumulator TensorArray.
+This double counts and generally breaks the TensorArray gradient flow.
+
+The solution is to identify which gradient call this particular
+TensorArray gradient is being called in.  This is performed by identifying
+a unique string (e.g. "gradients", "gradients_1", ...) from the input
+gradient Tensor's name.  This string is used as a suffix when creating
+the TensorArray gradient object here (the attribute `source`).
+
+The attribute `source` is added as a suffix to the forward TensorArray's
+name when performing the creation / lookup, so that each separate gradient
+calculation gets its own TensorArray accumulator.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayPack.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayPack.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..030950b06fcbf2fd5e0c2eed99e154640e0adbec
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayPack.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "TensorArrayPack"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayRead.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayRead.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1b62f7fac7c292e1efcc32b8211635df97127f98
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayRead.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "TensorArrayRead"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayReadV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayReadV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..934d7e432a6595682eeb231ff131e7fbdd4483e9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayReadV2.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "TensorArrayReadV2"
+  visibility: SKIP
+  summary: "Deprecated. Use TensorArrayReadV3"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayReadV3.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayReadV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4f07182f2b0fd94c6f841ceae14e431a5ff44fbd
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayReadV3.pbtxt
@@ -0,0 +1,31 @@
+op {
+  graph_op_name: "TensorArrayReadV3"
+  endpoint {
+    name: "TensorArrayRead"
+  }
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a TensorArray.
+END
+  }
+  in_arg {
+    name: "flow_in"
+    description: <<END
+A float scalar that enforces proper chaining of operations.
+END
+  }
+  out_arg {
+    name: "value"
+    description: <<END
+The tensor that is read from the TensorArray.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of the elem that is returned.
+END
+  }
+  summary: "Read an element from the TensorArray into output `value`."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayScatter.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayScatter.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a3e8d1625e96f50238ec34650cd2027804969e57
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayScatter.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "TensorArrayScatter"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayScatterV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayScatterV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..aa74b6af6ac9c3691b46b7c6316e7de6fa84f11d
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayScatterV2.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "TensorArrayScatterV2"
+  visibility: SKIP
+  summary: "Deprecated. Use TensorArrayScatterV3"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayScatterV3.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayScatterV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..69539e82593bcdf4e5375021fb251a66f4171e14
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayScatterV3.pbtxt
@@ -0,0 +1,40 @@
+op {
+  graph_op_name: "TensorArrayScatterV3"
+  endpoint {
+    name: "TensorArrayScatter"
+  }
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a TensorArray.
+END
+  }
+  in_arg {
+    name: "indices"
+    description: <<END
+The locations at which to write the tensor elements.
+END
+  }
+  in_arg {
+    name: "value"
+    description: <<END
+The concatenated tensor to write to the TensorArray.
+END
+  }
+  in_arg {
+    name: "flow_in"
+    description: <<END
+A float scalar that enforces proper chaining of operations.
+END
+  }
+  out_arg {
+    name: "flow_out"
+    description: <<END
+A float scalar that enforces proper chaining of operations.
+END
+  }
+  summary: "Scatter the data from the input value into specific TensorArray elements."
+  description: <<END
+`indices` must be a vector, its length must match the first dim of `value`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArraySize.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArraySize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fb3a6fae1c4cc95b8ccb2a020658c9d23bd1f69b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArraySize.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "TensorArraySize"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArraySizeV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArraySizeV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b9c74832360f30d68f6d3f01fa21f51b7d71c675
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArraySizeV2.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "TensorArraySizeV2"
+  visibility: SKIP
+  summary: "Deprecated. Use TensorArraySizeV3"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArraySizeV3.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArraySizeV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..76a7c8804f3848343a1ad432d411deecefedf678
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArraySizeV3.pbtxt
@@ -0,0 +1,25 @@
+op {
+  graph_op_name: "TensorArraySizeV3"
+  endpoint {
+    name: "TensorArraySize"
+  }
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a TensorArray (output of TensorArray or TensorArrayGrad).
+END
+  }
+  in_arg {
+    name: "flow_in"
+    description: <<END
+A float scalar that enforces proper chaining of operations.
+END
+  }
+  out_arg {
+    name: "size"
+    description: <<END
+The current size of the TensorArray.
+END
+  }
+  summary: "Get the current size of the TensorArray."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArraySplit.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArraySplit.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3eb8d6c7ffa8641822b5b93bebf06a47c1bf288b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArraySplit.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "TensorArraySplit"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArraySplitV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArraySplitV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..15a0b18d04a4842c5e9aee7cb85a45f8cc30df7c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArraySplitV2.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "TensorArraySplitV2"
+  visibility: SKIP
+  summary: "Deprecated. Use TensorArraySplitV3"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArraySplitV3.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArraySplitV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c2aeb4f660129e82f6a17b7f5665803881ce7452
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArraySplitV3.pbtxt
@@ -0,0 +1,57 @@
+op {
+  graph_op_name: "TensorArraySplitV3"
+  endpoint {
+    name: "TensorArraySplit"
+  }
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a TensorArray.
+END
+  }
+  in_arg {
+    name: "value"
+    description: <<END
+The concatenated tensor to write to the TensorArray.
+END
+  }
+  in_arg {
+    name: "lengths"
+    description: <<END
+The vector of lengths, how to split the rows of value into the
+TensorArray.
+END
+  }
+  in_arg {
+    name: "flow_in"
+    description: <<END
+A float scalar that enforces proper chaining of operations.
+END
+  }
+  out_arg {
+    name: "flow_out"
+    description: <<END
+A float scalar that enforces proper chaining of operations.
+END
+  }
+  summary: "Split the data from the input value into TensorArray elements."
+  description: <<END
+Assuming that `lengths` takes on values
+
+  ```(n0, n1, ..., n(T-1))```
+
+and that `value` has shape
+
+  ```(n0 + n1 + ... + n(T-1) x d0 x d1 x ...)```,
+
+this splits values into a TensorArray with T tensors.
+
+TensorArray index t will be the subtensor of values with starting position
+
+  ```(n0 + n1 + ... + n(t-1), 0, 0, ...)```
+
+and having size
+
+  ```nt x d0 x d1 x ...```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayUnpack.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayUnpack.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a9011de23ea12eee3de3f3ba83ff86907c6c967b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayUnpack.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "TensorArrayUnpack"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f4d58e7721071aa954c395e528a4eb761aa2524e
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayV2.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "TensorArrayV2"
+  visibility: SKIP
+  summary: "Deprecated. Use TensorArrayV3"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayV3.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d1de753ee59372fcb30fba7006f4864a33d3980f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayV3.pbtxt
@@ -0,0 +1,65 @@
+op {
+  graph_op_name: "TensorArrayV3"
+  endpoint {
+    name: "TensorArray"
+  }
+  in_arg {
+    name: "size"
+    description: <<END
+The size of the array.
+END
+  }
+  out_arg {
+    name: "handle"
+    description: <<END
+The handle to the TensorArray.
+END
+  }
+  out_arg {
+    name: "flow"
+    description: <<END
+A scalar used to control gradient flow.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of the elements on the tensor_array.
+END
+  }
+  attr {
+    name: "element_shape"
+    description: <<END
+The expected shape of an element, if known. Used to
+validate the shapes of TensorArray elements. If this shape is not
+fully specified, gathering zero-size TensorArrays is an error.
+END
+  }
+  attr {
+    name: "dynamic_size"
+    description: <<END
+A boolean that determines whether writes to the TensorArray
+are allowed to grow the size.  By default, this is not allowed.
+END
+  }
+  attr {
+    name: "clear_after_read"
+    description: <<END
+If true (default), Tensors in the TensorArray are cleared
+after being read.  This disables multiple read semantics but allows early
+release of memory.
+END
+  }
+  attr {
+    name: "tensor_array_name"
+    description: <<END
+Overrides the name used for the temporary tensor_array
+resource. Default value is the name of the 'TensorArray' op (which
+is guaranteed unique).
+END
+  }
+  summary: "An array of Tensors of given size."
+  description: <<END
+Write data via Write and read via Read or Pack.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayWrite.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayWrite.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..92ab1764ec8fa0524c8ce102f765fc200f1b44dd
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayWrite.pbtxt
@@ -0,0 +1,3 @@
+op {
+  graph_op_name: "TensorArrayWrite"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayWriteV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayWriteV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f7af8c3ab283c3b657eb06469933e06c4da99e62
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayWriteV2.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "TensorArrayWriteV2"
+  visibility: SKIP
+  summary: "Deprecated. Use TensorArrayGradV3"
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorArrayWriteV3.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorArrayWriteV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..312b4b472d9df17b6c8e7f4ce3aa890123d2086c
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorArrayWriteV3.pbtxt
@@ -0,0 +1,37 @@
+op {
+  graph_op_name: "TensorArrayWriteV3"
+  endpoint {
+    name: "TensorArrayWrite"
+  }
+  in_arg {
+    name: "handle"
+    description: <<END
+The handle to a TensorArray.
+END
+  }
+  in_arg {
+    name: "index"
+    description: <<END
+The position to write to inside the TensorArray.
+END
+  }
+  in_arg {
+    name: "value"
+    description: <<END
+The tensor to write to the TensorArray.
+END
+  }
+  in_arg {
+    name: "flow_in"
+    description: <<END
+A float scalar that enforces proper chaining of operations.
+END
+  }
+  out_arg {
+    name: "flow_out"
+    description: <<END
+A float scalar that enforces proper chaining of operations.
+END
+  }
+  summary: "Push an element onto the tensor_array."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..050e174aacb12b415357437e7f989b09faf40621
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorDataset.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorDataset"
+  summary: "Creates a dataset that emits `components` as a tuple of tensors once."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorSliceDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorSliceDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a26a98fd7f3a6564309efd28dff8c2bc93d7a67f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorSliceDataset.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorSliceDataset"
+  summary: "Creates a dataset that emits each dim-0 slice of `components` once."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorSummary.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorSummary.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7601e7e162f433d9fbd0a2c8ac2e226d89a0a3f6
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorSummary.pbtxt
@@ -0,0 +1,33 @@
+op {
+  graph_op_name: "TensorSummary"
+  in_arg {
+    name: "tensor"
+    description: <<END
+A tensor to serialize.
+END
+  }
+  attr {
+    name: "description"
+    description: <<END
+A json-encoded SummaryDescription proto.
+END
+  }
+  attr {
+    name: "labels"
+    description: <<END
+An unused list of strings.
+END
+  }
+  attr {
+    name: "display_name"
+    description: <<END
+An unused string.
+END
+  }
+  summary: "Outputs a `Summary` protocol buffer with a tensor."
+  description: <<END
+This op is being phased out in favor of TensorSummaryV2, which lets callers pass
+a tag as well as a serialized SummaryMetadata proto string that contains
+plugin-specific data. We will keep this op to maintain backwards compatibility.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TensorSummaryV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_TensorSummaryV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6e03c5dc059084700b7ad8bdc00f2429095b6250
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TensorSummaryV2.pbtxt
@@ -0,0 +1,23 @@
+op {
+  graph_op_name: "TensorSummaryV2"
+  in_arg {
+    name: "tag"
+    description: <<END
+A string attached to this summary. Used for organization in TensorBoard.
+END
+  }
+  in_arg {
+    name: "tensor"
+    description: <<END
+A tensor to serialize.
+END
+  }
+  in_arg {
+    name: "serialized_summary_metadata"
+    description: <<END
+A serialized SummaryMetadata proto. Contains plugin
+data.
+END
+  }
+  summary: "Outputs a `Summary` protocol buffer with a tensor and per-plugin data."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TextLineDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_TextLineDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6b630509964ed56ecaf401b10a46c5e53cd46528
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TextLineDataset.pbtxt
@@ -0,0 +1,24 @@
+op {
+  graph_op_name: "TextLineDataset"
+  in_arg {
+    name: "filenames"
+    description: <<END
+A scalar or a vector containing the name(s) of the file(s) to be
+read.
+END
+  }
+  in_arg {
+    name: "compression_type"
+    description: <<END
+A scalar containing either (i) the empty string (no
+compression), (ii) "ZLIB", or (iii) "GZIP".
+END
+  }
+  in_arg {
+    name: "buffer_size"
+    description: <<END
+A scalar containing the number of bytes to buffer.
+END
+  }
+  summary: "Creates a dataset that emits the lines of one or more text files."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TextLineReader.pbtxt b/tensorflow/core/api_def/base_api/api_def_TextLineReader.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..74ed1da8ff505fc724dfbeaa6645269bf239e3e0
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TextLineReader.pbtxt
@@ -0,0 +1,31 @@
+op {
+  graph_op_name: "TextLineReader"
+  visibility: SKIP
+  out_arg {
+    name: "reader_handle"
+    description: <<END
+The handle to reference the Reader.
+END
+  }
+  attr {
+    name: "skip_header_lines"
+    description: <<END
+Number of lines to skip from the beginning of every file.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this reader is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this reader is named in the given bucket
+with this shared_name. Otherwise, the node name is used instead.
+END
+  }
+  summary: "A Reader that outputs the lines of a file delimited by \'\\n\'."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TextLineReaderV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_TextLineReaderV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0de7655b74468afda7ce38ca470d67eb4b266955
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TextLineReaderV2.pbtxt
@@ -0,0 +1,33 @@
+op {
+  graph_op_name: "TextLineReaderV2"
+  endpoint {
+    name: "TextLineReader"
+  }
+  out_arg {
+    name: "reader_handle"
+    description: <<END
+The handle to reference the Reader.
+END
+  }
+  attr {
+    name: "skip_header_lines"
+    description: <<END
+Number of lines to skip from the beginning of every file.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this reader is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this reader is named in the given bucket
+with this shared_name. Otherwise, the node name is used instead.
+END
+  }
+  summary: "A Reader that outputs the lines of a file delimited by \'\\n\'."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ThreadUnsafeUnigramCandidateSampler.pbtxt b/tensorflow/core/api_def/base_api/api_def_ThreadUnsafeUnigramCandidateSampler.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2619aae806d4b1e42e0bca25f98ef5c9e908d264
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ThreadUnsafeUnigramCandidateSampler.pbtxt
@@ -0,0 +1,87 @@
+op {
+  graph_op_name: "ThreadUnsafeUnigramCandidateSampler"
+  visibility: SKIP
+  in_arg {
+    name: "true_classes"
+    description: <<END
+A batch_size * num_true matrix, in which each row contains the
+IDs of the num_true target_classes in the corresponding original label.
+END
+  }
+  out_arg {
+    name: "sampled_candidates"
+    description: <<END
+A vector of length num_sampled, in which each element is
+the ID of a sampled candidate.
+END
+  }
+  out_arg {
+    name: "true_expected_count"
+    description: <<END
+A batch_size * num_true matrix, representing
+the number of times each candidate is expected to occur in a batch
+of sampled candidates. If unique=true, then this is a probability.
+END
+  }
+  out_arg {
+    name: "sampled_expected_count"
+    description: <<END
+A vector of length num_sampled, for each sampled
+candidate representing the number of times the candidate is expected
+to occur in a batch of sampled candidates.  If unique=true, then this is a
+probability.
+END
+  }
+  attr {
+    name: "num_true"
+    description: <<END
+Number of true labels per context.
+END
+  }
+  attr {
+    name: "num_sampled"
+    description: <<END
+Number of candidates to randomly sample.
+END
+  }
+  attr {
+    name: "unique"
+    description: <<END
+If unique is true, we sample with rejection, so that all sampled
+candidates in a batch are unique. This requires some approximation to
+estimate the post-rejection sampling probabilities.
+END
+  }
+  attr {
+    name: "range_max"
+    description: <<END
+The sampler will sample integers from the interval [0, range_max).
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either seed or seed2 are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+An second seed to avoid seed collision.
+END
+  }
+  summary: "Generates labels for candidate sampling with a learned unigram distribution."
+  description: <<END
+See explanations of candidate sampling and the data formats at
+go/candidate-sampling.
+
+For each batch, this op picks a single set of sampled candidate labels.
+
+The advantages of sampling candidates per-batch are simplicity and the
+possibility of efficient dense matrix multiplication. The disadvantage is that
+the sampled candidates must be chosen independently of the context and of the
+true labels.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Tile.pbtxt b/tensorflow/core/api_def/base_api/api_def_Tile.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..97e1cae19c0e94fd40424538974b35e86b4a9ba5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Tile.pbtxt
@@ -0,0 +1,23 @@
+op {
+  graph_op_name: "Tile"
+  in_arg {
+    name: "input"
+    description: <<END
+1-D or higher.
+END
+  }
+  in_arg {
+    name: "multiples"
+    description: <<END
+1-D. Length must be the same as the number of dimensions in `input`
+END
+  }
+  summary: "Constructs a tensor by tiling a given tensor."
+  description: <<END
+This operation creates a new tensor by replicating `input` `multiples` times.
+The output tensor's i'th dimension has `input.dims(i) * multiples[i]` elements,
+and the values of `input` are replicated `multiples[i]` times along the 'i'th
+dimension. For example, tiling `[a b c d]` by `[2]` produces
+`[a b c d a b c d]`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TileGrad.pbtxt b/tensorflow/core/api_def/base_api/api_def_TileGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b211534259f766ecab4d2839c6dc6eaa5ea0d2b5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TileGrad.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "TileGrad"
+  summary: "Returns the gradient of `Tile`."
+  description: <<END
+Since `Tile` takes an input and repeats the input `multiples` times
+along each dimension, `TileGrad` takes in `multiples` and aggregates
+each repeated tile of `input` into `output`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TopK.pbtxt b/tensorflow/core/api_def/base_api/api_def_TopK.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c4060d0afab54c7f887fc677fc26bb512fa3c7d8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TopK.pbtxt
@@ -0,0 +1,50 @@
+op {
+  graph_op_name: "TopK"
+  in_arg {
+    name: "input"
+    description: <<END
+1-D or higher with last dimension at least `k`.
+END
+  }
+  out_arg {
+    name: "values"
+    description: <<END
+The `k` largest elements along each last dimensional slice.
+END
+  }
+  out_arg {
+    name: "indices"
+    description: <<END
+The indices of `values` within the last dimension of `input`.
+END
+  }
+  attr {
+    name: "k"
+    description: <<END
+Number of top elements to look for along the last dimension (along each
+row for matrices).
+END
+  }
+  attr {
+    name: "sorted"
+    description: <<END
+If true the resulting `k` elements will be sorted by the values in
+descending order.
+END
+  }
+  summary: "Finds values and indices of the `k` largest elements for the last dimension."
+  description: <<END
+If the input is a vector (rank-1), finds the `k` largest entries in the vector
+and outputs their values and indices as vectors.  Thus `values[j]` is the
+`j`-th largest entry in `input`, and its index is `indices[j]`.
+
+For matrices (resp. higher rank input), computes the top `k` entries in each
+row (resp. vector along the last dimension).  Thus,
+
+    values.shape = indices.shape = input.shape[:-1] + [k]
+
+If two elements are equal, the lower-index element appears first.
+
+If `k` varies dynamically, use `TopKV2` below.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TopKV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_TopKV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fd17df16a29060f3bbbd89cf4de96ee002ded87a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TopKV2.pbtxt
@@ -0,0 +1,51 @@
+op {
+  graph_op_name: "TopKV2"
+  endpoint {
+    name: "TopK"
+  }
+  in_arg {
+    name: "input"
+    description: <<END
+1-D or higher with last dimension at least `k`.
+END
+  }
+  in_arg {
+    name: "k"
+    description: <<END
+0-D.  Number of top elements to look for along the last dimension (along each
+row for matrices).
+END
+  }
+  out_arg {
+    name: "values"
+    description: <<END
+The `k` largest elements along each last dimensional slice.
+END
+  }
+  out_arg {
+    name: "indices"
+    description: <<END
+The indices of `values` within the last dimension of `input`.
+END
+  }
+  attr {
+    name: "sorted"
+    description: <<END
+If true the resulting `k` elements will be sorted by the values in
+descending order.
+END
+  }
+  summary: "Finds values and indices of the `k` largest elements for the last dimension."
+  description: <<END
+If the input is a vector (rank-1), finds the `k` largest entries in the vector
+and outputs their values and indices as vectors.  Thus `values[j]` is the
+`j`-th largest entry in `input`, and its index is `indices[j]`.
+
+For matrices (resp. higher rank input), computes the top `k` entries in each
+row (resp. vector along the last dimension).  Thus,
+
+    values.shape = indices.shape = input.shape[:-1] + [k]
+
+If two elements are equal, the lower-index element appears first.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Transpose.pbtxt b/tensorflow/core/api_def/base_api/api_def_Transpose.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0ec7fae659698d55a4429f8538c22b5df3258d81
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Transpose.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "Transpose"
+  summary: "Shuffle dimensions of x according to a permutation."
+  description: <<END
+The output `y` has the same rank as `x`. The shapes of `x` and `y` satisfy:
+  `y.shape[i] == x.shape[perm[i]] for i in [0, 1, ..., rank(x) - 1]`
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TruncateDiv.pbtxt b/tensorflow/core/api_def/base_api/api_def_TruncateDiv.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ef1b9873139f57425634d1bc1d715885dff22540
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TruncateDiv.pbtxt
@@ -0,0 +1,13 @@
+op {
+  graph_op_name: "TruncateDiv"
+  summary: "Returns x / y element-wise for integer types."
+  description: <<END
+Truncation designates that negative numbers will round fractional quantities
+toward zero. I.e. -7 / 5 = -1. This matches C semantics but it is different
+than Python semantics. See `FloorDiv` for a division function that matches
+Python Semantics.
+
+*NOTE*: `TruncateDiv` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TruncateMod.pbtxt b/tensorflow/core/api_def/base_api/api_def_TruncateMod.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..804f70ab52fb07ef940ee405b5f597a846c83757
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TruncateMod.pbtxt
@@ -0,0 +1,11 @@
+op {
+  graph_op_name: "TruncateMod"
+  summary: "Returns element-wise remainder of division. This emulates C semantics in that"
+  description: <<END
+the result here is consistent with a truncating divide. E.g. `truncate(x / y) *
+y + truncate_mod(x, y) = x`.
+
+*NOTE*: `TruncateMod` supports broadcasting. More about broadcasting
+[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_TruncatedNormal.pbtxt b/tensorflow/core/api_def/base_api/api_def_TruncatedNormal.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3da930d6f8ad252d55a4d1a96124fb7b7996fc89
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_TruncatedNormal.pbtxt
@@ -0,0 +1,42 @@
+op {
+  graph_op_name: "TruncatedNormal"
+  in_arg {
+    name: "shape"
+    description: <<END
+The shape of the output tensor.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+A tensor of the specified shape filled with random truncated normal
+values.
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either `seed` or `seed2` are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+A second seed to avoid seed collision.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of the output.
+END
+  }
+  summary: "Outputs random values from a truncated normal distribution."
+  description: <<END
+The generated values follow a normal distribution with mean 0 and standard
+deviation 1, except that values whose magnitude is more than 2 standard
+deviations from the mean are dropped and re-picked.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_U.pbtxt b/tensorflow/core/api_def/base_api/api_def_U.pbtxt
deleted file mode 100644
index 6699efc0e090fa120a26758463e90ae35765dc81..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_U.pbtxt
+++ /dev/null
@@ -1,150 +0,0 @@
-op {
-  graph_op_name: "UniformCandidateSampler"
-  endpoint {
-    name: "UniformCandidateSampler"
-  }
-  summary: "Generates labels for candidate sampling with a uniform distribution."
-  description: <<END
-See explanations of candidate sampling and the data formats at
-go/candidate-sampling.
-
-For each batch, this op picks a single set of sampled candidate labels.
-
-The advantages of sampling candidates per-batch are simplicity and the
-possibility of efficient dense matrix multiplication. The disadvantage is that
-the sampled candidates must be chosen independently of the context and of the
-true labels.
-END
-}
-op {
-  graph_op_name: "Unique"
-  endpoint {
-    name: "Unique"
-  }
-  summary: "Finds unique elements in a 1-D tensor."
-  description: <<END
-This operation returns a tensor `y` containing all of the unique elements of `x`
-sorted in the same order that they occur in `x`. This operation also returns a
-tensor `idx` the same size as `x` that contains the index of each value of `x`
-in the unique output `y`. In other words:
-
-`y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
-
-For example:
-
-```
-# tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
-y, idx = unique(x)
-y ==> [1, 2, 4, 7, 8]
-idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
-```
-END
-}
-op {
-  graph_op_name: "UniqueWithCounts"
-  endpoint {
-    name: "UniqueWithCounts"
-  }
-  summary: "Finds unique elements in a 1-D tensor."
-  description: <<END
-This operation returns a tensor `y` containing all of the unique elements of `x`
-sorted in the same order that they occur in `x`. This operation also returns a
-tensor `idx` the same size as `x` that contains the index of each value of `x`
-in the unique output `y`. Finally, it returns a third tensor `count` that
-contains the count of each element of `y` in `x`. In other words:
-
-`y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
-
-For example:
-
-```
-# tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
-y, idx, count = unique_with_counts(x)
-y ==> [1, 2, 4, 7, 8]
-idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
-count ==> [2, 1, 3, 1, 2]
-```
-END
-}
-op {
-  graph_op_name: "Unpack"
-  endpoint {
-    name: "Unpack"
-  }
-  summary: "Unpacks a given dimension of a rank-`R` tensor into `num` rank-`(R-1)` tensors."
-  description: <<END
-Unpacks `num` tensors from `value` by chipping it along the `axis` dimension.
-For example, given a tensor of shape `(A, B, C, D)`;
-
-If `axis == 0` then the i'th tensor in `output` is the slice `value[i, :, :, :]`
-  and each tensor in `output` will have shape `(B, C, D)`. (Note that the
-  dimension unpacked along is gone, unlike `split`).
-
-If `axis == 1` then the i'th tensor in `output` is the slice `value[:, i, :, :]`
-  and each tensor in `output` will have shape `(A, C, D)`.
-Etc.
-
-This is the opposite of `pack`.
-END
-}
-op {
-  graph_op_name: "UnsortedSegmentMax"
-  endpoint {
-    name: "UnsortedSegmentMax"
-  }
-  summary: "Computes the Max along segments of a tensor."
-  description: <<END
-Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
-segments.
-
-This operator is similar to the [unsorted segment sum operator](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).
-Instead of computing the sum over segments, it computes the maximum
-such that:
-
-\\(output_i = \max_j data_j\\) where max is over `j` such
-that `segment_ids[j] == i`.
-
-If the maximum is empty for a given segment ID `i`, it outputs the smallest possible value for specific numeric type,
- `output[i] = numeric_limits<T>::min()`.
-
-<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-<img style="width:100%" src="https://www.tensorflow.org/images/UnsortedSegmentMax.png" alt>
-</div>
-END
-}
-op {
-  graph_op_name: "UnsortedSegmentSum"
-  endpoint {
-    name: "UnsortedSegmentSum"
-  }
-  summary: "Computes the sum along segments of a tensor."
-  description: <<END
-Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
-segments.
-
-Computes a tensor such that
-`(output[i] = sum_{j...} data[j...]` where the sum is over tuples `j...` such
-that `segment_ids[j...] == i`.  Unlike `SegmentSum`, `segment_ids`
-need not be sorted and need not cover all values in the full
-range of valid values.
-
-If the sum is empty for a given segment ID `i`, `output[i] = 0`.
-
-`num_segments` should equal the number of distinct segment IDs.
-
-<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-<img style="width:100%" src="https://www.tensorflow.org/images/UnsortedSegmentSum.png" alt>
-</div>
-END
-}
-op {
-  graph_op_name: "Unstage"
-  endpoint {
-    name: "Unstage"
-  }
-  summary: "Op is similar to a lightweight Dequeue."
-  description: <<END
-The basic functionality is similar to dequeue with many fewer
-capabilities and options.  This Op is optimized for performance.
-END
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_UniformCandidateSampler.pbtxt b/tensorflow/core/api_def/base_api/api_def_UniformCandidateSampler.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4cf431a2e121cbac943331ab069168716f17685b
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_UniformCandidateSampler.pbtxt
@@ -0,0 +1,86 @@
+op {
+  graph_op_name: "UniformCandidateSampler"
+  in_arg {
+    name: "true_classes"
+    description: <<END
+A batch_size * num_true matrix, in which each row contains the
+IDs of the num_true target_classes in the corresponding original label.
+END
+  }
+  out_arg {
+    name: "sampled_candidates"
+    description: <<END
+A vector of length num_sampled, in which each element is
+the ID of a sampled candidate.
+END
+  }
+  out_arg {
+    name: "true_expected_count"
+    description: <<END
+A batch_size * num_true matrix, representing
+the number of times each candidate is expected to occur in a batch
+of sampled candidates. If unique=true, then this is a probability.
+END
+  }
+  out_arg {
+    name: "sampled_expected_count"
+    description: <<END
+A vector of length num_sampled, for each sampled
+candidate representing the number of times the candidate is expected
+to occur in a batch of sampled candidates.  If unique=true, then this is a
+probability.
+END
+  }
+  attr {
+    name: "num_true"
+    description: <<END
+Number of true labels per context.
+END
+  }
+  attr {
+    name: "num_sampled"
+    description: <<END
+Number of candidates to randomly sample.
+END
+  }
+  attr {
+    name: "unique"
+    description: <<END
+If unique is true, we sample with rejection, so that all sampled
+candidates in a batch are unique. This requires some approximation to
+estimate the post-rejection sampling probabilities.
+END
+  }
+  attr {
+    name: "range_max"
+    description: <<END
+The sampler will sample integers from the interval [0, range_max).
+END
+  }
+  attr {
+    name: "seed"
+    description: <<END
+If either seed or seed2 are set to be non-zero, the random number
+generator is seeded by the given seed.  Otherwise, it is seeded by a
+random seed.
+END
+  }
+  attr {
+    name: "seed2"
+    description: <<END
+An second seed to avoid seed collision.
+END
+  }
+  summary: "Generates labels for candidate sampling with a uniform distribution."
+  description: <<END
+See explanations of candidate sampling and the data formats at
+go/candidate-sampling.
+
+For each batch, this op picks a single set of sampled candidate labels.
+
+The advantages of sampling candidates per-batch are simplicity and the
+possibility of efficient dense matrix multiplication. The disadvantage is that
+the sampled candidates must be chosen independently of the context and of the
+true labels.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Unique.pbtxt b/tensorflow/core/api_def/base_api/api_def_Unique.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a35b67e7b5a14abf28141b8a00e7b5dc61932bdf
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Unique.pbtxt
@@ -0,0 +1,39 @@
+op {
+  graph_op_name: "Unique"
+  in_arg {
+    name: "x"
+    description: <<END
+1-D.
+END
+  }
+  out_arg {
+    name: "y"
+    description: <<END
+1-D.
+END
+  }
+  out_arg {
+    name: "idx"
+    description: <<END
+1-D.
+END
+  }
+  summary: "Finds unique elements in a 1-D tensor."
+  description: <<END
+This operation returns a tensor `y` containing all of the unique elements of `x`
+sorted in the same order that they occur in `x`. This operation also returns a
+tensor `idx` the same size as `x` that contains the index of each value of `x`
+in the unique output `y`. In other words:
+
+`y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
+
+For example:
+
+```
+# tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
+y, idx = unique(x)
+y ==> [1, 2, 4, 7, 8]
+idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_UniqueWithCounts.pbtxt b/tensorflow/core/api_def/base_api/api_def_UniqueWithCounts.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..02d670644f094410675642456a89ce6e2a77cb00
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_UniqueWithCounts.pbtxt
@@ -0,0 +1,47 @@
+op {
+  graph_op_name: "UniqueWithCounts"
+  in_arg {
+    name: "x"
+    description: <<END
+1-D.
+END
+  }
+  out_arg {
+    name: "y"
+    description: <<END
+1-D.
+END
+  }
+  out_arg {
+    name: "idx"
+    description: <<END
+1-D.
+END
+  }
+  out_arg {
+    name: "count"
+    description: <<END
+1-D.
+END
+  }
+  summary: "Finds unique elements in a 1-D tensor."
+  description: <<END
+This operation returns a tensor `y` containing all of the unique elements of `x`
+sorted in the same order that they occur in `x`. This operation also returns a
+tensor `idx` the same size as `x` that contains the index of each value of `x`
+in the unique output `y`. Finally, it returns a third tensor `count` that
+contains the count of each element of `y` in `x`. In other words:
+
+`y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
+
+For example:
+
+```
+# tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
+y, idx, count = unique_with_counts(x)
+y ==> [1, 2, 4, 7, 8]
+idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
+count ==> [2, 1, 3, 1, 2]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Unpack.pbtxt b/tensorflow/core/api_def/base_api/api_def_Unpack.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..716aa73956cdae3ce3bf5cacb133faecd1dc61f8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Unpack.pbtxt
@@ -0,0 +1,40 @@
+op {
+  graph_op_name: "Unpack"
+  endpoint {
+    name: "Unstack"
+  }
+  in_arg {
+    name: "value"
+    description: <<END
+1-D or higher, with `axis` dimension size equal to `num`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+The list of tensors unpacked from `value`.
+END
+  }
+  attr {
+    name: "axis"
+    description: <<END
+Dimension along which to unpack.  Negative values wrap around, so the
+valid range is `[-R, R)`.
+END
+  }
+  summary: "Unpacks a given dimension of a rank-`R` tensor into `num` rank-`(R-1)` tensors."
+  description: <<END
+Unpacks `num` tensors from `value` by chipping it along the `axis` dimension.
+For example, given a tensor of shape `(A, B, C, D)`;
+
+If `axis == 0` then the i'th tensor in `output` is the slice `value[i, :, :, :]`
+  and each tensor in `output` will have shape `(B, C, D)`. (Note that the
+  dimension unpacked along is gone, unlike `split`).
+
+If `axis == 1` then the i'th tensor in `output` is the slice `value[:, i, :, :]`
+  and each tensor in `output` will have shape `(A, C, D)`.
+Etc.
+
+This is the opposite of `pack`.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_UnsortedSegmentMax.pbtxt b/tensorflow/core/api_def/base_api/api_def_UnsortedSegmentMax.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8298d62f253160847ee34bcdea5a81c7370e5124
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_UnsortedSegmentMax.pbtxt
@@ -0,0 +1,36 @@
+op {
+  graph_op_name: "UnsortedSegmentMax"
+  in_arg {
+    name: "segment_ids"
+    description: <<END
+A 1-D tensor whose rank is equal to the rank of `data`'s
+first dimension.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Has same shape as data, except for dimension 0 which
+has size `num_segments`.
+END
+  }
+  summary: "Computes the Max along segments of a tensor."
+  description: <<END
+Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
+segments.
+
+This operator is similar to the [unsorted segment sum operator](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).
+Instead of computing the sum over segments, it computes the maximum
+such that:
+
+\\(output_i = \max_j data_j\\) where max is over `j` such
+that `segment_ids[j] == i`.
+
+If the maximum is empty for a given segment ID `i`, it outputs the smallest possible value for specific numeric type,
+ `output[i] = numeric_limits<T>::min()`.
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src="https://www.tensorflow.org/images/UnsortedSegmentMax.png" alt>
+</div>
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_UnsortedSegmentSum.pbtxt b/tensorflow/core/api_def/base_api/api_def_UnsortedSegmentSum.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0a3355cdbc0ba594205a765f2e975ff87078ec71
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_UnsortedSegmentSum.pbtxt
@@ -0,0 +1,36 @@
+op {
+  graph_op_name: "UnsortedSegmentSum"
+  in_arg {
+    name: "segment_ids"
+    description: <<END
+A tensor whose shape is a prefix of `data.shape`.
+END
+  }
+  out_arg {
+    name: "output"
+    description: <<END
+Has same shape as data, except for the first `segment_ids.rank`
+dimensions, which are replaced with a single dimension which has size
+`num_segments`.
+END
+  }
+  summary: "Computes the sum along segments of a tensor."
+  description: <<END
+Read @{$math_ops#segmentation$the section on segmentation} for an explanation of
+segments.
+
+Computes a tensor such that
+`(output[i] = sum_{j...} data[j...]` where the sum is over tuples `j...` such
+that `segment_ids[j...] == i`.  Unlike `SegmentSum`, `segment_ids`
+need not be sorted and need not cover all values in the full
+range of valid values.
+
+If the sum is empty for a given segment ID `i`, `output[i] = 0`.
+
+`num_segments` should equal the number of distinct segment IDs.
+
+<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+<img style="width:100%" src="https://www.tensorflow.org/images/UnsortedSegmentSum.png" alt>
+</div>
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Unstage.pbtxt b/tensorflow/core/api_def/base_api/api_def_Unstage.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2e18658430b57ca868b0ec58db35542a3f77993a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Unstage.pbtxt
@@ -0,0 +1,8 @@
+op {
+  graph_op_name: "Unstage"
+  summary: "Op is similar to a lightweight Dequeue."
+  description: <<END
+The basic functionality is similar to dequeue with many fewer
+capabilities and options.  This Op is optimized for performance.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_V.pbtxt b/tensorflow/core/api_def/base_api/api_def_V.pbtxt
deleted file mode 100644
index 31cc147900957b6e0afe9a7075fc701b25eba342..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_V.pbtxt
+++ /dev/null
@@ -1,19 +0,0 @@
-op {
-  graph_op_name: "Variable"
-  endpoint {
-    name: "Variable"
-  }
-  summary: "Use VariableV2 instead."
-}
-op {
-  graph_op_name: "VariableV2"
-  endpoint {
-    name: "VariableV2"
-  }
-  summary: "Holds state in the form of a tensor that persists across steps."
-  description: <<END
-Outputs a ref to the tensor state so it may be read or modified.
-TODO(zhifengc/mrry): Adds a pointer to a more detail document
-about sharing states in tensorflow.
-END
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_VarHandleOp.pbtxt b/tensorflow/core/api_def/base_api/api_def_VarHandleOp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0a4caa06bdb2f9f92ed43f4d4658c7101e622885
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_VarHandleOp.pbtxt
@@ -0,0 +1,29 @@
+op {
+  graph_op_name: "VarHandleOp"
+  attr {
+    name: "container"
+    description: <<END
+the container this variable is placed in.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+the name by which this variable is referred to.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+the type of this variable. Must agree with the dtypes
+of all ops using this variable.
+END
+  }
+  attr {
+    name: "shape"
+    description: <<END
+The (possibly partially specified) shape of this variable.
+END
+  }
+  summary: "Creates a handle to a Variable resource."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_VarIsInitializedOp.pbtxt b/tensorflow/core/api_def/base_api/api_def_VarIsInitializedOp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a9c4cfd0b9549d0de3f457b035dd752b6b9d33e8
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_VarIsInitializedOp.pbtxt
@@ -0,0 +1,17 @@
+op {
+  graph_op_name: "VarIsInitializedOp"
+  in_arg {
+    name: "resource"
+    description: <<END
+the input resource handle.
+END
+  }
+  out_arg {
+    name: "is_initialized"
+    description: <<END
+a scalar boolean which is true if the variable has been
+initialized.
+END
+  }
+  summary: "Checks whether a resource handle-based variable has been initialized."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Variable.pbtxt b/tensorflow/core/api_def/base_api/api_def_Variable.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..112ab6549f47815bd0c1cc947c48f5d8b56f3b6f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Variable.pbtxt
@@ -0,0 +1,5 @@
+op {
+  graph_op_name: "Variable"
+  visibility: SKIP
+  summary: "Use VariableV2 instead."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_VariableShape.pbtxt b/tensorflow/core/api_def/base_api/api_def_VariableShape.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..adc4bf08fa9a44488399aeea64d98441ff630822
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_VariableShape.pbtxt
@@ -0,0 +1,14 @@
+op {
+  graph_op_name: "VariableShape"
+  summary: "Returns the shape of the variable pointed to by `resource`."
+  description: <<END
+This operation returns a 1-D integer tensor representing the shape of `input`.
+
+For example:
+
+```
+# 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
+shape(t) ==> [2, 2, 3]
+```
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_VariableV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_VariableV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6341cc69f61dd7fd127bdfdcfde836fce4fcd443
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_VariableV2.pbtxt
@@ -0,0 +1,44 @@
+op {
+  graph_op_name: "VariableV2"
+  endpoint {
+    name: "Variable"
+  }
+  out_arg {
+    name: "ref"
+    description: <<END
+A reference to the variable tensor.
+END
+  }
+  attr {
+    name: "shape"
+    description: <<END
+The shape of the variable tensor.
+END
+  }
+  attr {
+    name: "dtype"
+    description: <<END
+The type of elements in the variable tensor.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this variable is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this variable is named in the given bucket
+with this shared_name. Otherwise, the node name is used instead.
+END
+  }
+  summary: "Holds state in the form of a tensor that persists across steps."
+  description: <<END
+Outputs a ref to the tensor state so it may be read or modified.
+TODO(zhifengc/mrry): Adds a pointer to a more detail document
+about sharing states in tensorflow.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_W.pbtxt b/tensorflow/core/api_def/base_api/api_def_Where.pbtxt
similarity index 51%
rename from tensorflow/core/api_def/base_api/api_def_W.pbtxt
rename to tensorflow/core/api_def/base_api/api_def_Where.pbtxt
index 9120fe334edbdcf720f5ac421048479fc4d23d93..a6ea62c4ccc0701ecd29209cb706fa08698e8ab6 100644
--- a/tensorflow/core/api_def/base_api/api_def_W.pbtxt
+++ b/tensorflow/core/api_def/base_api/api_def_Where.pbtxt
@@ -1,9 +1,10 @@
 op {
   graph_op_name: "Where"
-  endpoint {
-    name: "Where"
+  in_arg {
+    name: "input"
+    rename_to: "condition"
   }
-  summary: "Returns locations of true values in a boolean tensor."
+  summary: "Returns locations of nonzero / true values in a tensor."
   description: <<END
 This operation returns the coordinates of true elements in `input`. The
 coordinates are returned in a 2-D tensor where the first dimension (rows)
@@ -30,6 +31,34 @@ where(input) ==> [[0, 0],
 #                     [False, True]]]
 # 'input' has 5 true values, so output has 5 coordinates.
 # 'input' has rank of 3, so coordinates have three indices.
+where(input) ==> [[0, 0, 0],
+                  [0, 1, 0],
+                  [1, 0, 1],
+                  [1, 1, 1],
+                  [2, 1, 1]]
+
+# `input` tensor is [[[1.5,  0.0]
+#                     [-0.5, 0.0]]
+#                    [[0.0,  0.25]
+#                     [0.0,  0.75]]
+#                    [[0.0,  0.0]
+#                     [0.0,  0.01]]]
+# 'input' has 5 nonzero values, so output has 5 coordinates.
+# 'input' has rank of 3, so coordinates have three indices.
+where(input) ==> [[0, 0, 0],
+                  [0, 1, 0],
+                  [1, 0, 1],
+                  [1, 1, 1],
+                  [2, 1, 1]]
+
+# `input` tensor is [[[1.5 + 0.0j, 0.0  + 0.0j]
+#                     [0.0 + 0.5j, 0.0  + 0.0j]]
+#                    [[0.0 + 0.0j, 0.25 + 1.5j]
+#                     [0.0 + 0.0j, 0.75 + 0.0j]]
+#                    [[0.0 + 0.0j, 0.0  + 0.0j]
+#                     [0.0 + 0.0j, 0.01 + 0.0j]]]
+# 'input' has 5 nonzero magnitude values, so output has 5 coordinates.
+# 'input' has rank of 3, so coordinates have three indices.
 where(input) ==> [[0, 0, 0],
                   [0, 1, 0],
                   [1, 0, 1],
@@ -38,35 +67,3 @@ where(input) ==> [[0, 0, 0],
 ```
 END
 }
-op {
-  graph_op_name: "WholeFileReader"
-  endpoint {
-    name: "WholeFileReader"
-  }
-  summary: "A Reader that outputs the entire contents of a file as a value."
-  description: <<END
-To use, enqueue filenames in a Queue.  The output of ReaderRead will
-be a filename (key) and the contents of that file (value).
-END
-}
-op {
-  graph_op_name: "WholeFileReaderV2"
-  endpoint {
-    name: "WholeFileReaderV2"
-  }
-  summary: "A Reader that outputs the entire contents of a file as a value."
-  description: <<END
-To use, enqueue filenames in a Queue.  The output of ReaderRead will
-be a filename (key) and the contents of that file (value).
-END
-}
-op {
-  graph_op_name: "WriteFile"
-  endpoint {
-    name: "WriteFile"
-  }
-  summary: "Writes contents to the file at input filename. Creates file and recursively"
-  description: <<END
-creates directory if not existing.
-END
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_WholeFileReader.pbtxt b/tensorflow/core/api_def/base_api/api_def_WholeFileReader.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..32180e0737f790c3e12a62ed658c74c75f5a4cdc
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_WholeFileReader.pbtxt
@@ -0,0 +1,29 @@
+op {
+  graph_op_name: "WholeFileReader"
+  visibility: SKIP
+  out_arg {
+    name: "reader_handle"
+    description: <<END
+The handle to reference the Reader.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this reader is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this reader is named in the given bucket
+with this shared_name. Otherwise, the node name is used instead.
+END
+  }
+  summary: "A Reader that outputs the entire contents of a file as a value."
+  description: <<END
+To use, enqueue filenames in a Queue.  The output of ReaderRead will
+be a filename (key) and the contents of that file (value).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_WholeFileReaderV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_WholeFileReaderV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f9063f9588964fa21a3902981e4a7d53c2a9a0f9
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_WholeFileReaderV2.pbtxt
@@ -0,0 +1,31 @@
+op {
+  graph_op_name: "WholeFileReaderV2"
+  endpoint {
+    name: "WholeFileReader"
+  }
+  out_arg {
+    name: "reader_handle"
+    description: <<END
+The handle to reference the Reader.
+END
+  }
+  attr {
+    name: "container"
+    description: <<END
+If non-empty, this reader is placed in the given container.
+Otherwise, a default container is used.
+END
+  }
+  attr {
+    name: "shared_name"
+    description: <<END
+If non-empty, this reader is named in the given bucket
+with this shared_name. Otherwise, the node name is used instead.
+END
+  }
+  summary: "A Reader that outputs the entire contents of a file as a value."
+  description: <<END
+To use, enqueue filenames in a Queue.  The output of ReaderRead will
+be a filename (key) and the contents of that file (value).
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_WriteFile.pbtxt b/tensorflow/core/api_def/base_api/api_def_WriteFile.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..28b09c9bf12f31b2e6dff36ec146b3abfb21359f
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_WriteFile.pbtxt
@@ -0,0 +1,19 @@
+op {
+  graph_op_name: "WriteFile"
+  in_arg {
+    name: "filename"
+    description: <<END
+scalar. The name of the file to which we write the contents.
+END
+  }
+  in_arg {
+    name: "contents"
+    description: <<END
+scalar. The content to be written to the output file.
+END
+  }
+  summary: "Writes contents to the file at input filename. Creates file and recursively"
+  description: <<END
+creates directory if not existing.
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Z.pbtxt b/tensorflow/core/api_def/base_api/api_def_Z.pbtxt
deleted file mode 100644
index f83fef054c6ab1e9270b3bf1d5d7143052954152..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/base_api/api_def_Z.pbtxt
+++ /dev/null
@@ -1,27 +0,0 @@
-op {
-  graph_op_name: "ZerosLike"
-  endpoint {
-    name: "ZerosLike"
-  }
-  summary: "Returns a tensor of zeros with the same shape and type as x."
-}
-op {
-  graph_op_name: "Zeta"
-  endpoint {
-    name: "Zeta"
-  }
-  summary: "Compute the Hurwitz zeta function \\\\(\\zeta(x, q)\\\\)."
-  description: <<END
-The Hurwitz zeta function is defined as:
-
-
-\\(\zeta(x, q) = \sum_{n=0}^{\infty} (q + n)^{-x}\\)
-END
-}
-op {
-  graph_op_name: "ZipDataset"
-  endpoint {
-    name: "ZipDataset"
-  }
-  summary: "Creates a dataset that zips together `input_datasets`."
-}
diff --git a/tensorflow/core/api_def/base_api/api_def_ZerosLike.pbtxt b/tensorflow/core/api_def/base_api/api_def_ZerosLike.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..37c2d5b53405902b2f834facc57f8eeeab87010a
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ZerosLike.pbtxt
@@ -0,0 +1,16 @@
+op {
+  graph_op_name: "ZerosLike"
+  in_arg {
+    name: "x"
+    description: <<END
+a tensor of type T.
+END
+  }
+  out_arg {
+    name: "y"
+    description: <<END
+a tensor of the same shape and type as x but filled with zeros.
+END
+  }
+  summary: "Returns a tensor of zeros with the same shape and type as x."
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_Zeta.pbtxt b/tensorflow/core/api_def/base_api/api_def_Zeta.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c02860a16ab4edceb03cd0f00e621b6950574ef5
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_Zeta.pbtxt
@@ -0,0 +1,10 @@
+op {
+  graph_op_name: "Zeta"
+  summary: "Compute the Hurwitz zeta function \\\\(\\zeta(x, q)\\\\)."
+  description: <<END
+The Hurwitz zeta function is defined as:
+
+
+\\(\zeta(x, q) = \sum_{n=0}^{\infty} (q + n)^{-x}\\)
+END
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_ZipDataset.pbtxt b/tensorflow/core/api_def/base_api/api_def_ZipDataset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7495693ccc50fede4a359d13aa710a1fd2fd9402
--- /dev/null
+++ b/tensorflow/core/api_def/base_api/api_def_ZipDataset.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ZipDataset"
+  summary: "Creates a dataset that zips together `input_datasets`."
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_A.pbtxt b/tensorflow/core/api_def/python_api/api_def_A.pbtxt
deleted file mode 100644
index df9b3ad0b69235eaf22c1b84b624e4037084547d..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/python_api/api_def_A.pbtxt
+++ /dev/null
@@ -1,56 +0,0 @@
-op {
-  graph_op_name: "Abs"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "AddManySparseToTensorsMap"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "AddN"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "AddSparseToTensorsMap"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "AdjustContrastv2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "All"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "AllCandidateSampler"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Any"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Assert"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "AudioSummary"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "AudioSummaryV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "AvgPool"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "AvgPool3DGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "AvgPoolGrad"
-  visibility: HIDDEN
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_Abs.pbtxt b/tensorflow/core/api_def/python_api/api_def_Abs.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1f21fae28bdf579eba47f4b530032b21652a8bc0
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Abs.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Abs"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_AccumulateNV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_AccumulateNV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a92ff5a4065f562b848d1508fde7efec2d31b34d
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_AccumulateNV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "AccumulateNV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_AddManySparseToTensorsMap.pbtxt b/tensorflow/core/api_def/python_api/api_def_AddManySparseToTensorsMap.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7ece23fd65d200b12695dd7411dec74b7d3947fb
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_AddManySparseToTensorsMap.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "AddManySparseToTensorsMap"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_AddN.pbtxt b/tensorflow/core/api_def/python_api/api_def_AddN.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8cc22ad4dc50af8f9d298b95806bc2e5feee5285
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_AddN.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "AddN"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_AddSparseToTensorsMap.pbtxt b/tensorflow/core/api_def/python_api/api_def_AddSparseToTensorsMap.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c4446bba28032ea74fce9ada48052fd021534eb1
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_AddSparseToTensorsMap.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "AddSparseToTensorsMap"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_AddV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_AddV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..77c879c6b3684c18df119cc36519c48bc6af56b4
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_AddV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "AddV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_AdjustContrastv2.pbtxt b/tensorflow/core/api_def/python_api/api_def_AdjustContrastv2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..889d14740697e84846d4380a3fcaec400a03bccc
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_AdjustContrastv2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "AdjustContrastv2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_All.pbtxt b/tensorflow/core/api_def/python_api/api_def_All.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ca780f037fb6d26d89ca5b5d7b110936567590ee
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_All.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "All"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_AllCandidateSampler.pbtxt b/tensorflow/core/api_def/python_api/api_def_AllCandidateSampler.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..200ae0ae490ce4e88aa314a246377c5206f544d8
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_AllCandidateSampler.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "AllCandidateSampler"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Any.pbtxt b/tensorflow/core/api_def/python_api/api_def_Any.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4afa8acecbeafb6734631f2f4d9ef4927cb2a930
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Any.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Any"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Assert.pbtxt b/tensorflow/core/api_def/python_api/api_def_Assert.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..12e27ee0bc430e8e33ecba88f6e5600626918963
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Assert.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Assert"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_AudioSummary.pbtxt b/tensorflow/core/api_def/python_api/api_def_AudioSummary.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..94da1e06ea9a03b6ebb90e1ad03e9110b95e4aee
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_AudioSummary.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "AudioSummary"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_AudioSummaryV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_AudioSummaryV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1715576d0924456170c27e8e46cb80d0d76471e5
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_AudioSummaryV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "AudioSummaryV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_AvgPool.pbtxt b/tensorflow/core/api_def/python_api/api_def_AvgPool.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c58d6c6039b56d7528c00e573e6ae2f4113b03b3
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_AvgPool.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "AvgPool"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_AvgPool3DGrad.pbtxt b/tensorflow/core/api_def/python_api/api_def_AvgPool3DGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5e4049faf497977f6bb35b9df8fd2aec24484f34
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_AvgPool3DGrad.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "AvgPool3DGrad"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_B.pbtxt b/tensorflow/core/api_def/python_api/api_def_B.pbtxt
deleted file mode 100644
index 49c74ccad28f8e1ecc12b5ad0ce6a054670da36a..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/python_api/api_def_B.pbtxt
+++ /dev/null
@@ -1,142 +0,0 @@
-op {
-  graph_op_name: "Barrier"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BarrierClose"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BarrierIncompleteSize"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BarrierInsertMany"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BarrierReadySize"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BarrierTakeMany"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchCholesky"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchCholeskyGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchFFT"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchFFT2D"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchFFT3D"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchIFFT"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchIFFT2D"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchIFFT3D"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchMatMul"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchMatrixDeterminant"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchMatrixInverse"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchMatrixSolve"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchMatrixSolveLs"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchMatrixTriangularSolve"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchNormWithGlobalNormalization"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchNormWithGlobalNormalizationGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchSelfAdjointEig"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchSelfAdjointEigV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchSvd"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BatchToSpace"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BiasAdd"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BiasAddV1"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BitwiseAnd"
-  endpoint {
-    name: "bitwise.bitwise_and"
-  }
-}
-op {
-  graph_op_name: "BitwiseOr"
-  endpoint {
-    name: "bitwise.bitwise_or"
-  }
-}
-op {
-  graph_op_name: "BitwiseXor"
-  endpoint {
-    name: "bitwise.bitwise_xor"
-  }
-}
-op {
-  graph_op_name: "BroadcastArgs"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "BroadcastGradientArgs"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Bucketize"
-  visibility: HIDDEN
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_Barrier.pbtxt b/tensorflow/core/api_def/python_api/api_def_Barrier.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b6463fcf618eea63b43c04c4c6125bb6e4cc0712
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Barrier.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Barrier"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BarrierClose.pbtxt b/tensorflow/core/api_def/python_api/api_def_BarrierClose.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d903a2e29ea2e82fb1b6dbc3f95b9496656de4a1
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BarrierClose.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BarrierClose"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BarrierIncompleteSize.pbtxt b/tensorflow/core/api_def/python_api/api_def_BarrierIncompleteSize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e9c5a8e7fea1160ed573809fbc861d18320238b1
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BarrierIncompleteSize.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BarrierIncompleteSize"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BarrierInsertMany.pbtxt b/tensorflow/core/api_def/python_api/api_def_BarrierInsertMany.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3c7b060d41f6529699eff4158a7ddedc40d42365
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BarrierInsertMany.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BarrierInsertMany"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BarrierReadySize.pbtxt b/tensorflow/core/api_def/python_api/api_def_BarrierReadySize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..07729e0704a586af0b3220d480c7ff1fe07f4937
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BarrierReadySize.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BarrierReadySize"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BarrierTakeMany.pbtxt b/tensorflow/core/api_def/python_api/api_def_BarrierTakeMany.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..de6448e3fe9a56729753848cef8a1f42e0c8cc86
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BarrierTakeMany.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BarrierTakeMany"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchCholesky.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchCholesky.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..83241f8e8bdf37f5211b44338aadb69110dc58e6
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchCholesky.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchCholesky"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchCholeskyGrad.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchCholeskyGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..60ddfd7a26955803cd07484de6dd10045b6f572d
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchCholeskyGrad.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchCholeskyGrad"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchFFT.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchFFT.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f735280687df93c09f7347ccf5ff147171ade9b0
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchFFT.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchFFT"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchFFT2D.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchFFT2D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a7520e86d4944daf9d97ca0d35e234bcea0da1af
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchFFT2D.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchFFT2D"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchFFT3D.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchFFT3D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..27bc32046b04809a5d9e22c42478dcf02239bad8
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchFFT3D.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchFFT3D"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchIFFT.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchIFFT.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7f3bb2ba5d83951b450fea4973e1e662d035b67e
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchIFFT.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchIFFT"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchIFFT2D.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchIFFT2D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b94492459554abf799dc95328e9f5b29b0a149a5
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchIFFT2D.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchIFFT2D"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchIFFT3D.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchIFFT3D.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..13cccda1d2f6afae54d1263050d34cd0e280231a
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchIFFT3D.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchIFFT3D"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchMatMul.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchMatMul.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b3db197c2670341a438254b4c766adf529376c98
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchMatMul.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchMatMul"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchMatrixDeterminant.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchMatrixDeterminant.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..202b0d149b1dc26fa2b5ba356d451367de549127
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchMatrixDeterminant.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchMatrixDeterminant"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchMatrixInverse.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchMatrixInverse.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3fa68bdd3e085e4929e5f82a6fd1af1802e83b7d
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchMatrixInverse.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchMatrixInverse"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchMatrixSolve.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchMatrixSolve.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a458423e38def986f4ccd62db967341051b3174c
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchMatrixSolve.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchMatrixSolve"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchMatrixSolveLs.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchMatrixSolveLs.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..61b4ca3999b034a41d7ab88dd41ed8276252034a
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchMatrixSolveLs.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchMatrixSolveLs"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchMatrixTriangularSolve.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchMatrixTriangularSolve.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..28e674259577ef63859098165f448bdfd43c14ee
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchMatrixTriangularSolve.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchMatrixTriangularSolve"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchNormWithGlobalNormalization.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchNormWithGlobalNormalization.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e7a042bc617a3e4cd610045c0fc77e0b3bd7bd5b
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchNormWithGlobalNormalization.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchNormWithGlobalNormalization"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchNormWithGlobalNormalizationGrad.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchNormWithGlobalNormalizationGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e92f3a30f401b2a0569b043b81e70c762469f628
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchNormWithGlobalNormalizationGrad.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchNormWithGlobalNormalizationGrad"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchSelfAdjointEig.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchSelfAdjointEig.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..26fef1c4b43d32c8e91ab607191833c052a3805d
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchSelfAdjointEig.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchSelfAdjointEig"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchSelfAdjointEigV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchSelfAdjointEigV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..660523a8c458c203dc3215e101fc0409076d88a7
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchSelfAdjointEigV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchSelfAdjointEigV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchSvd.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchSvd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..927f5483a9707da09233b6909fcfcda0f66721ad
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchSvd.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchSvd"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BatchToSpace.pbtxt b/tensorflow/core/api_def/python_api/api_def_BatchToSpace.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c106bb1367e74eabad03e489238098c6780c7d21
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BatchToSpace.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BatchToSpace"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BiasAdd.pbtxt b/tensorflow/core/api_def/python_api/api_def_BiasAdd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c2397ac0ac7717075f817ef83e78a7d5700279ca
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BiasAdd.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BiasAdd"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BiasAddV1.pbtxt b/tensorflow/core/api_def/python_api/api_def_BiasAddV1.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..93dcabecb8d0e709860f77924720763d5d33c807
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BiasAddV1.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BiasAddV1"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BitwiseAnd.pbtxt b/tensorflow/core/api_def/python_api/api_def_BitwiseAnd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..288a3f5fc201a663efe2c651c465205739c13b94
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BitwiseAnd.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "BitwiseAnd"
+  endpoint {
+    name: "bitwise.bitwise_and"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BitwiseOr.pbtxt b/tensorflow/core/api_def/python_api/api_def_BitwiseOr.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..150dbf6bfd8ae53649654589a81b3c99603b9b02
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BitwiseOr.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "BitwiseOr"
+  endpoint {
+    name: "bitwise.bitwise_or"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BitwiseXor.pbtxt b/tensorflow/core/api_def/python_api/api_def_BitwiseXor.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4f7c6fb5fceaea12d97409fc9ebe65825ea3ea3d
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BitwiseXor.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "BitwiseXor"
+  endpoint {
+    name: "bitwise.bitwise_xor"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_BroadcastArgs.pbtxt b/tensorflow/core/api_def/python_api/api_def_BroadcastArgs.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5933fdfea1a389fc78b50e9f78153188d9fe5d92
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_BroadcastArgs.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "BroadcastArgs"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Bucketize.pbtxt b/tensorflow/core/api_def/python_api/api_def_Bucketize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..49fbe175aeb3a09f04f982c31f584e58c689c59c
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Bucketize.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Bucketize"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_C.pbtxt b/tensorflow/core/api_def/python_api/api_def_C.pbtxt
deleted file mode 100644
index 42ed24b1336efb59d835c87980f032adde59344a..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/python_api/api_def_C.pbtxt
+++ /dev/null
@@ -1,59 +0,0 @@
-op {
-  graph_op_name: "CTCBeamSearchDecoder"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "CTCGreedyDecoder"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "CTCLoss"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Cholesky"
-  endpoint {
-    name: "cholesky"
-  }
-  endpoint {
-    name: "linalg.cholesky"
-  }
-}
-op {
-  graph_op_name: "Complex"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ComplexAbs"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ComputeAccidentalHits"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Concat"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ConcatOffset"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ConcatV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Conj"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Const"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "CropAndResize"
-  endpoint {
-    name: "image.crop_and_resize"
-  }
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_CTCBeamSearchDecoder.pbtxt b/tensorflow/core/api_def/python_api/api_def_CTCBeamSearchDecoder.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4cc4ad05aa6497542965fd2dd095e3bf457b7b8a
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_CTCBeamSearchDecoder.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "CTCBeamSearchDecoder"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_CTCGreedyDecoder.pbtxt b/tensorflow/core/api_def/python_api/api_def_CTCGreedyDecoder.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4b540add1f541737086177784f06fa05429594aa
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_CTCGreedyDecoder.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "CTCGreedyDecoder"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_CTCLoss.pbtxt b/tensorflow/core/api_def/python_api/api_def_CTCLoss.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a0c6bcd3949a378e6045e17920b9fe10189b6164
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_CTCLoss.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "CTCLoss"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Cholesky.pbtxt b/tensorflow/core/api_def/python_api/api_def_Cholesky.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2676c92bfbebeab6eac3f4052c0394e5bda1a767
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Cholesky.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "Cholesky"
+  endpoint {
+    name: "cholesky"
+  }
+  endpoint {
+    name: "linalg.cholesky"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Complex.pbtxt b/tensorflow/core/api_def/python_api/api_def_Complex.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b9ec8059f79a8bcff547e87a0e59af0f2e355d40
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Complex.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Complex"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ComplexAbs.pbtxt b/tensorflow/core/api_def/python_api/api_def_ComplexAbs.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..77a8a44872ff442a2336e9d2ea194588dcb15ed0
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ComplexAbs.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ComplexAbs"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ComputeAccidentalHits.pbtxt b/tensorflow/core/api_def/python_api/api_def_ComputeAccidentalHits.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..744949639c8e5e3d90e453c96f5530bbb08e68e0
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ComputeAccidentalHits.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ComputeAccidentalHits"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Concat.pbtxt b/tensorflow/core/api_def/python_api/api_def_Concat.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..503e87cd6c60a436b02b230f3e73adca63fc44e7
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Concat.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Concat"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ConcatOffset.pbtxt b/tensorflow/core/api_def/python_api/api_def_ConcatOffset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d1bcb77e00fe5845107441cdd486097694584dd4
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ConcatOffset.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ConcatOffset"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ConcatV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_ConcatV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d5b5321fdc7759e83d7e5bb9574aabb014c6650e
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ConcatV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ConcatV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Conj.pbtxt b/tensorflow/core/api_def/python_api/api_def_Conj.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c36b1f7fadc45ef9f65b7ce9127749ef093ac7f6
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Conj.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Conj"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ConjugateTranspose.pbtxt b/tensorflow/core/api_def/python_api/api_def_ConjugateTranspose.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6a8de53e735039daa6836767b166d781e81841e3
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ConjugateTranspose.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ConjugateTranspose"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Const.pbtxt b/tensorflow/core/api_def/python_api/api_def_Const.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..95d162ac41539a588fee13199f66009e6c276a10
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Const.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Const"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_CropAndResize.pbtxt b/tensorflow/core/api_def/python_api/api_def_CropAndResize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ce65f8172ddfea2ae08750cf37bba8e3e012f5f5
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_CropAndResize.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "CropAndResize"
+  endpoint {
+    name: "image.crop_and_resize"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_D.pbtxt b/tensorflow/core/api_def/python_api/api_def_D.pbtxt
deleted file mode 100644
index c73982aed0cd718f65645f248e6dd16115d948c5..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/python_api/api_def_D.pbtxt
+++ /dev/null
@@ -1,74 +0,0 @@
-op {
-  graph_op_name: "DebugGradientIdentity"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "DecodeAndCropJpeg"
-  endpoint {
-    name: "image.decode_and_crop_jpeg"
-  }
-}
-op {
-  graph_op_name: "DecodeBmp"
-  endpoint {
-    name: "image.decode_bmp"
-  }
-}
-op {
-  graph_op_name: "DecodeCSV"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "DecodeGif"
-  endpoint {
-    name: "image.decode_gif"
-  }
-}
-op {
-  graph_op_name: "DecodeJpeg"
-  endpoint {
-    name: "image.decode_jpeg"
-  }
-}
-op {
-  graph_op_name: "DecodePng"
-  endpoint {
-    name: "image.decode_png"
-  }
-}
-op {
-  graph_op_name: "DeleteSessionTensor"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "DepthwiseConv2dNative"
-  endpoint {
-    name: "nn.depthwise_conv2d_native"
-  }
-}
-op {
-  graph_op_name: "DepthwiseConv2dNativeBackpropFilter"
-  endpoint {
-    name: "nn.depthwise_conv2d_native_backprop_filter"
-  }
-}
-op {
-  graph_op_name: "DepthwiseConv2dNativeBackpropInput"
-  endpoint {
-    name: "nn.depthwise_conv2d_native_backprop_input"
-  }
-}
-op {
-  graph_op_name: "DeserializeManySparse"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "DestroyTemporaryVariable"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "DrawBoundingBoxes"
-  endpoint {
-    name: "image.draw_bounding_boxes"
-  }
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_DebugGradientIdentity.pbtxt b/tensorflow/core/api_def/python_api/api_def_DebugGradientIdentity.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7d50c5c8687a2cb3f550a04654fc6f0d7ec86a89
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_DebugGradientIdentity.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "DebugGradientIdentity"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_DecodeAndCropJpeg.pbtxt b/tensorflow/core/api_def/python_api/api_def_DecodeAndCropJpeg.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fbe9c882538776abb35b7c654ede0fffbfaa078c
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_DecodeAndCropJpeg.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "DecodeAndCropJpeg"
+  endpoint {
+    name: "image.decode_and_crop_jpeg"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_DecodeBmp.pbtxt b/tensorflow/core/api_def/python_api/api_def_DecodeBmp.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..573d83f3739a86d00550c519cb19aef452813927
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_DecodeBmp.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "DecodeBmp"
+  endpoint {
+    name: "image.decode_bmp"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_DecodeCSV.pbtxt b/tensorflow/core/api_def/python_api/api_def_DecodeCSV.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..21ef77e381b1975a1865a4096853a08baf04793e
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_DecodeCSV.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "DecodeCSV"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_DecodeGif.pbtxt b/tensorflow/core/api_def/python_api/api_def_DecodeGif.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..eed64df79cf7837c1cc0580dd2cb0f06acf289cc
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_DecodeGif.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "DecodeGif"
+  endpoint {
+    name: "image.decode_gif"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_DecodeJpeg.pbtxt b/tensorflow/core/api_def/python_api/api_def_DecodeJpeg.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..994bc4e1f4fd1707579ac2bda4fae5ed327430ab
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_DecodeJpeg.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "DecodeJpeg"
+  endpoint {
+    name: "image.decode_jpeg"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_DecodePng.pbtxt b/tensorflow/core/api_def/python_api/api_def_DecodePng.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..309eec5ac368297563af7e6e752921fd270186ef
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_DecodePng.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "DecodePng"
+  endpoint {
+    name: "image.decode_png"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_DeleteSessionTensor.pbtxt b/tensorflow/core/api_def/python_api/api_def_DeleteSessionTensor.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..08bf4a80ec64bb3a3eb5312502d68576bee18ce1
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_DeleteSessionTensor.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "DeleteSessionTensor"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_DepthwiseConv2dNative.pbtxt b/tensorflow/core/api_def/python_api/api_def_DepthwiseConv2dNative.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1bb17e548d1cd0ca77d6415b7fa165b1a6b7cae3
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_DepthwiseConv2dNative.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "DepthwiseConv2dNative"
+  endpoint {
+    name: "nn.depthwise_conv2d_native"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_DepthwiseConv2dNativeBackpropFilter.pbtxt b/tensorflow/core/api_def/python_api/api_def_DepthwiseConv2dNativeBackpropFilter.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6f9df4b1a11459c252f2961fb1caacaad64021ae
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_DepthwiseConv2dNativeBackpropFilter.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "DepthwiseConv2dNativeBackpropFilter"
+  endpoint {
+    name: "nn.depthwise_conv2d_native_backprop_filter"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_DepthwiseConv2dNativeBackpropInput.pbtxt b/tensorflow/core/api_def/python_api/api_def_DepthwiseConv2dNativeBackpropInput.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0bd72539e932f597e86f63ef52519652f0e8efd7
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_DepthwiseConv2dNativeBackpropInput.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "DepthwiseConv2dNativeBackpropInput"
+  endpoint {
+    name: "nn.depthwise_conv2d_native_backprop_input"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_DeserializeManySparse.pbtxt b/tensorflow/core/api_def/python_api/api_def_DeserializeManySparse.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fd43a05577905bc9918a56ac40a701f20ec953c8
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_DeserializeManySparse.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "DeserializeManySparse"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_DestroyTemporaryVariable.pbtxt b/tensorflow/core/api_def/python_api/api_def_DestroyTemporaryVariable.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e51a25a2c022b5d6289d2a8b6b79097f4d6b77a5
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_DestroyTemporaryVariable.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "DestroyTemporaryVariable"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_DrawBoundingBoxes.pbtxt b/tensorflow/core/api_def/python_api/api_def_DrawBoundingBoxes.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..54d644c013b123ef862ea6b9fe04d59f9fa59499
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_DrawBoundingBoxes.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "DrawBoundingBoxes"
+  endpoint {
+    name: "image.draw_bounding_boxes"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_E.pbtxt b/tensorflow/core/api_def/python_api/api_def_E.pbtxt
deleted file mode 100644
index 236c344167a825a3476bb2a51534eee19bc3d138..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/python_api/api_def_E.pbtxt
+++ /dev/null
@@ -1,46 +0,0 @@
-op {
-  graph_op_name: "EditDistance"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Elu"
-  endpoint {
-    name: "nn.elu"
-  }
-}
-op {
-  graph_op_name: "EluGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "EncodeJpeg"
-  endpoint {
-    name: "image.encode_jpeg"
-  }
-}
-op {
-  graph_op_name: "EncodePng"
-  endpoint {
-    name: "image.encode_png"
-  }
-}
-op {
-  graph_op_name: "Exit"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ExpandDims"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ExtractGlimpse"
-  endpoint {
-    name: "image.extract_glimpse"
-  }
-}
-op {
-  graph_op_name: "ExtractJpegShape"
-  endpoint {
-    name: "image.extract_jpeg_shape"
-  }
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_EditDistance.pbtxt b/tensorflow/core/api_def/python_api/api_def_EditDistance.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c77accf370719c9781c950c897cb9e9186bcacc5
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_EditDistance.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "EditDistance"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Elu.pbtxt b/tensorflow/core/api_def/python_api/api_def_Elu.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..15a9f6568f373cd6e8a44677c7f4ae557f85bc8f
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Elu.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "Elu"
+  endpoint {
+    name: "nn.elu"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_EncodeJpeg.pbtxt b/tensorflow/core/api_def/python_api/api_def_EncodeJpeg.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5c31e9d0f32e6e13ba7d87d8a234e238c048a8b9
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_EncodeJpeg.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "EncodeJpeg"
+  endpoint {
+    name: "image.encode_jpeg"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_EncodePng.pbtxt b/tensorflow/core/api_def/python_api/api_def_EncodePng.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..42717ba7d56abc2aa75c208b4a9ad51086ad1381
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_EncodePng.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "EncodePng"
+  endpoint {
+    name: "image.encode_png"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ExpandDims.pbtxt b/tensorflow/core/api_def/python_api/api_def_ExpandDims.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..29979dbf0a5110bce226dbe5ed2ae31f543ea708
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ExpandDims.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ExpandDims"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ExtractGlimpse.pbtxt b/tensorflow/core/api_def/python_api/api_def_ExtractGlimpse.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ed8abdfcd7f3171d431adf07d47eb3bfc60d1e8f
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ExtractGlimpse.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "ExtractGlimpse"
+  endpoint {
+    name: "image.extract_glimpse"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ExtractJpegShape.pbtxt b/tensorflow/core/api_def/python_api/api_def_ExtractJpegShape.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6849a6d3fa5f37b0d4f92829c8b07754b922a319
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ExtractJpegShape.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "ExtractJpegShape"
+  endpoint {
+    name: "image.extract_jpeg_shape"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_F.pbtxt b/tensorflow/core/api_def/python_api/api_def_F.pbtxt
deleted file mode 100644
index a29b6a372513b8e463563212291d655c2e501615..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/python_api/api_def_F.pbtxt
+++ /dev/null
@@ -1,73 +0,0 @@
-op {
-  graph_op_name: "FFT"
-  endpoint {
-    name: "fft"
-  }
-  endpoint {
-    name: "spectral.fft"
-  }
-}
-op {
-  graph_op_name: "FIFOQueue"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "FIFOQueueV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Fact"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "FakeQueue"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "FixedLengthRecordReader"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "FixedLengthRecordReaderV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "FixedUnigramCandidateSampler"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "FloorDiv"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "FloorMod"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "FractionalAvgPool"
-  endpoint {
-    name: "nn.fractional_avg_pool"
-  }
-}
-op {
-  graph_op_name: "FractionalAvgPoolGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "FractionalMaxPool"
-  endpoint {
-    name: "nn.fractional_max_pool"
-  }
-}
-op {
-  graph_op_name: "FractionalMaxPoolGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "FusedBatchNorm"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "FusedBatchNormV2"
-  visibility: HIDDEN
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_FFT.pbtxt b/tensorflow/core/api_def/python_api/api_def_FFT.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3bcab994151c012719d423c4031ad6699cd5a717
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_FFT.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "FFT"
+  endpoint {
+    name: "fft"
+  }
+  endpoint {
+    name: "spectral.fft"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_FIFOQueue.pbtxt b/tensorflow/core/api_def/python_api/api_def_FIFOQueue.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b51063b2cfef6372822babb300f8412ebf1e94e5
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_FIFOQueue.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "FIFOQueue"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_FIFOQueueV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_FIFOQueueV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..850fe5b89985cb7c2fe1560339f18899e43b1fa2
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_FIFOQueueV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "FIFOQueueV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Fact.pbtxt b/tensorflow/core/api_def/python_api/api_def_Fact.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9a8328bb8431abc41a154a9af505fa71ee92fe68
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Fact.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Fact"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_FakeQueue.pbtxt b/tensorflow/core/api_def/python_api/api_def_FakeQueue.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0c5cc7116b85fbf8f4d21ea5a9595391aeefcedd
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_FakeQueue.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "FakeQueue"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_FixedLengthRecordReader.pbtxt b/tensorflow/core/api_def/python_api/api_def_FixedLengthRecordReader.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..da211a3bfcf09d4e3ca13911c35cdb27170b65db
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_FixedLengthRecordReader.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "FixedLengthRecordReader"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_FixedLengthRecordReaderV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_FixedLengthRecordReaderV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c4606991e9905837cf8100f6dfd56119075888fa
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_FixedLengthRecordReaderV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "FixedLengthRecordReaderV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_FixedUnigramCandidateSampler.pbtxt b/tensorflow/core/api_def/python_api/api_def_FixedUnigramCandidateSampler.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ca70db18acd8b561bd3fbed72e5cfb873eceea2d
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_FixedUnigramCandidateSampler.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "FixedUnigramCandidateSampler"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_FloorDiv.pbtxt b/tensorflow/core/api_def/python_api/api_def_FloorDiv.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..26598ab1fb918e251d4c4da7b14810ebf4c44779
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_FloorDiv.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "FloorDiv"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_FloorMod.pbtxt b/tensorflow/core/api_def/python_api/api_def_FloorMod.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ef562e93a0dee0a3f24716719cb24232302626dc
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_FloorMod.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "FloorMod"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_FractionalAvgPool.pbtxt b/tensorflow/core/api_def/python_api/api_def_FractionalAvgPool.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..16ed9b56f2b662b6cca44f5c955e579c2f9d7971
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_FractionalAvgPool.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "FractionalAvgPool"
+  endpoint {
+    name: "nn.fractional_avg_pool"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_FractionalMaxPool.pbtxt b/tensorflow/core/api_def/python_api/api_def_FractionalMaxPool.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..695559520805abd02e0575f7f85937d00f0dc5fd
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_FractionalMaxPool.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "FractionalMaxPool"
+  endpoint {
+    name: "nn.fractional_max_pool"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_FusedBatchNorm.pbtxt b/tensorflow/core/api_def/python_api/api_def_FusedBatchNorm.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0ac0fe72522c109af75a6595858013c8f89701c6
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_FusedBatchNorm.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "FusedBatchNorm"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_FusedBatchNormV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_FusedBatchNormV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..70a79c906ed5356fc0e0261c7ebab998bcd2e602
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_FusedBatchNormV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "FusedBatchNormV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_G.pbtxt b/tensorflow/core/api_def/python_api/api_def_G.pbtxt
deleted file mode 100644
index 8235d245feb5403600532cfd05456e256b3faf0d..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/python_api/api_def_G.pbtxt
+++ /dev/null
@@ -1,16 +0,0 @@
-op {
-  graph_op_name: "GenerateVocabRemapping"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "GetSessionHandle"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "GetSessionHandleV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "GetSessionTensor"
-  visibility: HIDDEN
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_GenerateVocabRemapping.pbtxt b/tensorflow/core/api_def/python_api/api_def_GenerateVocabRemapping.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..35f09938512eb0f48cb1fc4cbaf3d94f83477279
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_GenerateVocabRemapping.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "GenerateVocabRemapping"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_GetSessionHandle.pbtxt b/tensorflow/core/api_def/python_api/api_def_GetSessionHandle.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..18396a1277099cd6de1926958ccdb3f51b0329ec
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_GetSessionHandle.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "GetSessionHandle"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_GetSessionHandleV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_GetSessionHandleV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..39cbcca12238663dad37fa2f220a806083732da6
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_GetSessionHandleV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "GetSessionHandleV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_GetSessionTensor.pbtxt b/tensorflow/core/api_def/python_api/api_def_GetSessionTensor.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2ef75ed34d9165d4af35ef17ad6f6b3c3a06a156
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_GetSessionTensor.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "GetSessionTensor"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_H.pbtxt b/tensorflow/core/api_def/python_api/api_def_H.pbtxt
deleted file mode 100644
index 9f3fe2eb08a384e5e74018b8089d8fc6293deb03..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/python_api/api_def_H.pbtxt
+++ /dev/null
@@ -1,18 +0,0 @@
-op {
-  graph_op_name: "HSVToRGB"
-  endpoint {
-    name: "image.hsv_to_rgb"
-  }
-}
-op {
-  graph_op_name: "HashTable"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "HashTableV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "HistogramSummary"
-  visibility: HIDDEN
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_HSVToRGB.pbtxt b/tensorflow/core/api_def/python_api/api_def_HSVToRGB.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..55998189f47e1fc211975ed45575d23f0a1aca5b
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_HSVToRGB.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "HSVToRGB"
+  endpoint {
+    name: "image.hsv_to_rgb"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_HashTable.pbtxt b/tensorflow/core/api_def/python_api/api_def_HashTable.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d1c5b2a4dc758c7b1d38b93a7cc4e682a7518ceb
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_HashTable.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "HashTable"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_HashTableV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_HashTableV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d702d4d0de84c26d7d2ba229286c9c69ef253be1
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_HashTableV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "HashTableV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_HistogramFixedWidth.pbtxt b/tensorflow/core/api_def/python_api/api_def_HistogramFixedWidth.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6cb4d9192e4e671c0a270afb0405b381490eee87
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_HistogramFixedWidth.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "HistogramFixedWidth"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_HistogramSummary.pbtxt b/tensorflow/core/api_def/python_api/api_def_HistogramSummary.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..644807d16f40001552b1c41fa0f9bbd35dfe3a1c
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_HistogramSummary.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "HistogramSummary"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_I.pbtxt b/tensorflow/core/api_def/python_api/api_def_I.pbtxt
deleted file mode 100644
index db6a54dbd43030c433c5716cefe2fe410694031a..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/python_api/api_def_I.pbtxt
+++ /dev/null
@@ -1,55 +0,0 @@
-op {
-  graph_op_name: "IFFT"
-  endpoint {
-    name: "ifft"
-  }
-  endpoint {
-    name: "spectral.ifft"
-  }
-}
-op {
-  graph_op_name: "IdentityReader"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "IdentityReaderV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ImageSummary"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "InTopK"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "InTopKV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "InitializeTable"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "InitializeTableFromTextFile"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "InitializeTableFromTextFileV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "InitializeTableV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "InvGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Invert"
-  endpoint {
-    name: "bitwise.invert"
-  }
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_IFFT.pbtxt b/tensorflow/core/api_def/python_api/api_def_IFFT.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6bbc4ed7207faefc74031a11949bbdafc59c9236
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_IFFT.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "IFFT"
+  endpoint {
+    name: "ifft"
+  }
+  endpoint {
+    name: "spectral.ifft"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_IdentityReader.pbtxt b/tensorflow/core/api_def/python_api/api_def_IdentityReader.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0a337f152090235b00f3b280843e350ad025a018
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_IdentityReader.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "IdentityReader"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_IdentityReaderV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_IdentityReaderV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..efafd76c712e3d01c2eb8c49478f36af115e1392
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_IdentityReaderV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "IdentityReaderV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ImageSummary.pbtxt b/tensorflow/core/api_def/python_api/api_def_ImageSummary.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..521c8850232ede2ef5a57299cf7cb7da0c403220
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ImageSummary.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ImageSummary"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_InTopK.pbtxt b/tensorflow/core/api_def/python_api/api_def_InTopK.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..357b9df14b8ed66116a8a217286c6d1b90f3d681
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_InTopK.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "InTopK"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_InTopKV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_InTopKV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a0a1c9e8314c5d53377d70b97019a6149a7fc4a1
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_InTopKV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "InTopKV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_InitializeTable.pbtxt b/tensorflow/core/api_def/python_api/api_def_InitializeTable.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..068030c755ea894e619c286e4b5c0184f3bb6f60
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_InitializeTable.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "InitializeTable"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_InitializeTableFromTextFile.pbtxt b/tensorflow/core/api_def/python_api/api_def_InitializeTableFromTextFile.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..dd0e586976e391c831460400154dd54f8de11b62
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_InitializeTableFromTextFile.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "InitializeTableFromTextFile"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_InitializeTableFromTextFileV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_InitializeTableFromTextFileV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..659642056d7ab36c89b125117aad6991a09047f2
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_InitializeTableFromTextFileV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "InitializeTableFromTextFileV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_InitializeTableV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_InitializeTableV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ee73655258fe41b7de617b0f8e5c314690ceee49
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_InitializeTableV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "InitializeTableV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Invert.pbtxt b/tensorflow/core/api_def/python_api/api_def_Invert.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a41d05a3c937bdc8fc24f28ef9d5c37535337d4e
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Invert.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "Invert"
+  endpoint {
+    name: "bitwise.invert"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_L.pbtxt b/tensorflow/core/api_def/python_api/api_def_L.pbtxt
deleted file mode 100644
index 083fbdae6f5706745ce763a23d4aaec25ca51b3c..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/python_api/api_def_L.pbtxt
+++ /dev/null
@@ -1,96 +0,0 @@
-op {
-  graph_op_name: "L2Loss"
-  endpoint {
-    name: "nn.l2_loss"
-  }
-}
-op {
-  graph_op_name: "LMDBReader"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "LRN"
-  endpoint {
-    name: "nn.local_response_normalization"
-  }
-  endpoint {
-    name: "nn.lrn"
-  }
-}
-op {
-  graph_op_name: "LRNGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "LearnedUnigramCandidateSampler"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "LinSpace"
-  endpoint {
-    name: "lin_space"
-  }
-  endpoint {
-    name: "linspace"
-  }
-}
-op {
-  graph_op_name: "ListDiff"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "LoadAndRemapMatrix"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "LogMatrixDeterminant"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "LogSoftmax"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "LogUniformCandidateSampler"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "LookupTableExport"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "LookupTableExportV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "LookupTableFind"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "LookupTableFindV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "LookupTableImport"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "LookupTableImportV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "LookupTableInsert"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "LookupTableInsertV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "LookupTableSize"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "LookupTableSizeV2"
-  visibility: HIDDEN
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_L2Loss.pbtxt b/tensorflow/core/api_def/python_api/api_def_L2Loss.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..de994e7f0a7a87e647657a87c54130cc8abda33c
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_L2Loss.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "L2Loss"
+  endpoint {
+    name: "nn.l2_loss"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LMDBReader.pbtxt b/tensorflow/core/api_def/python_api/api_def_LMDBReader.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..63e261f6de92e2c0fe45982cddc0acae7dc8e310
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LMDBReader.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "LMDBReader"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LRN.pbtxt b/tensorflow/core/api_def/python_api/api_def_LRN.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b6567fe33e93dda12574a1da57266c352cec5a3b
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LRN.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "LRN"
+  endpoint {
+    name: "nn.local_response_normalization"
+  }
+  endpoint {
+    name: "nn.lrn"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LearnedUnigramCandidateSampler.pbtxt b/tensorflow/core/api_def/python_api/api_def_LearnedUnigramCandidateSampler.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b005fe81c8ae49a8d393817f2416bdf019df9383
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LearnedUnigramCandidateSampler.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "LearnedUnigramCandidateSampler"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LeftShift.pbtxt b/tensorflow/core/api_def/python_api/api_def_LeftShift.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bf703f3897e5bc2243f9b41dfce4ed7d4c229d7e
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LeftShift.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "LeftShift"
+  endpoint {
+    name: "bitwise.left_shift"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LinSpace.pbtxt b/tensorflow/core/api_def/python_api/api_def_LinSpace.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b1de2cb207d221593b41d82d43b759e49d411710
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LinSpace.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "LinSpace"
+  endpoint {
+    name: "lin_space"
+  }
+  endpoint {
+    name: "linspace"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ListDiff.pbtxt b/tensorflow/core/api_def/python_api/api_def_ListDiff.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6718d5bec126c27c8fe3d9204c320d178894c030
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ListDiff.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ListDiff"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LoadAndRemapMatrix.pbtxt b/tensorflow/core/api_def/python_api/api_def_LoadAndRemapMatrix.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ac0f612443a5cc69c409ef4b65901b5ab97d655f
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LoadAndRemapMatrix.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "LoadAndRemapMatrix"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LogMatrixDeterminant.pbtxt b/tensorflow/core/api_def/python_api/api_def_LogMatrixDeterminant.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..36d1eadab4ecb5aa71ffd6bb9526b6b6592f10ee
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LogMatrixDeterminant.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "LogMatrixDeterminant"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LogSoftmax.pbtxt b/tensorflow/core/api_def/python_api/api_def_LogSoftmax.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6fde770eecb818fa6819ad54a64442864f393b2c
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LogSoftmax.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "LogSoftmax"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LogUniformCandidateSampler.pbtxt b/tensorflow/core/api_def/python_api/api_def_LogUniformCandidateSampler.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..276f1f576b2545c836a2c94146292edc5374e991
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LogUniformCandidateSampler.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "LogUniformCandidateSampler"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LookupTableExport.pbtxt b/tensorflow/core/api_def/python_api/api_def_LookupTableExport.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..016ad8dc60d7d45ca2328b9cc586a5e2c6dcb9fe
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LookupTableExport.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "LookupTableExport"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LookupTableExportV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_LookupTableExportV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..37e9746cccf3d0a608d590bef23138978f356448
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LookupTableExportV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "LookupTableExportV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LookupTableFind.pbtxt b/tensorflow/core/api_def/python_api/api_def_LookupTableFind.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..739196deb9d3812072262cca51f6a4694cc3c41c
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LookupTableFind.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "LookupTableFind"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LookupTableFindV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_LookupTableFindV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..da3be6db4269266a9e8fe9f3d588ecdcde8c431d
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LookupTableFindV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "LookupTableFindV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LookupTableImport.pbtxt b/tensorflow/core/api_def/python_api/api_def_LookupTableImport.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..52634b6fb0eb3b0d4fac09b6c7ff2540b86b464a
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LookupTableImport.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "LookupTableImport"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LookupTableImportV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_LookupTableImportV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..75a4e00473d83815e30d46c8398d614eda4a9dfb
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LookupTableImportV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "LookupTableImportV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LookupTableInsert.pbtxt b/tensorflow/core/api_def/python_api/api_def_LookupTableInsert.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..72dcc5fe6b604d4d813a6cb8746fc4d2c3ceec3b
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LookupTableInsert.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "LookupTableInsert"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LookupTableInsertV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_LookupTableInsertV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..14ca6f80a580606b9a6c7fe504c008ee773b7a08
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LookupTableInsertV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "LookupTableInsertV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LookupTableSize.pbtxt b/tensorflow/core/api_def/python_api/api_def_LookupTableSize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..203b51aee441118abdc649969dd840f91bb8da1e
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LookupTableSize.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "LookupTableSize"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_LookupTableSizeV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_LookupTableSizeV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ba26ba072410e5587708e41eae621f8a6b1ca51e
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_LookupTableSizeV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "LookupTableSizeV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_M.pbtxt b/tensorflow/core/api_def/python_api/api_def_M.pbtxt
deleted file mode 100644
index c8840e0c09009992a51b4ca08fb0fc3e97868ec6..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/python_api/api_def_M.pbtxt
+++ /dev/null
@@ -1,174 +0,0 @@
-op {
-  graph_op_name: "MatMul"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MatrixBandPart"
-  endpoint {
-    name: "linalg.band_part"
-  }
-  endpoint {
-    name: "matrix_band_part"
-  }
-}
-op {
-  graph_op_name: "MatrixDeterminant"
-  endpoint {
-    name: "linalg.det"
-  }
-  endpoint {
-    name: "matrix_determinant"
-  }
-}
-op {
-  graph_op_name: "MatrixDiag"
-  endpoint {
-    name: "linalg.diag"
-  }
-  endpoint {
-    name: "matrix_diag"
-  }
-}
-op {
-  graph_op_name: "MatrixDiagPart"
-  endpoint {
-    name: "linalg.diag_part"
-  }
-  endpoint {
-    name: "matrix_diag_part"
-  }
-}
-op {
-  graph_op_name: "MatrixInverse"
-  endpoint {
-    name: "linalg.inv"
-  }
-  endpoint {
-    name: "matrix_inverse"
-  }
-}
-op {
-  graph_op_name: "MatrixSetDiag"
-  endpoint {
-    name: "linalg.set_diag"
-  }
-  endpoint {
-    name: "matrix_set_diag"
-  }
-}
-op {
-  graph_op_name: "MatrixSolve"
-  endpoint {
-    name: "linalg.solve"
-  }
-  endpoint {
-    name: "matrix_solve"
-  }
-}
-op {
-  graph_op_name: "MatrixSolveLs"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MatrixTriangularSolve"
-  endpoint {
-    name: "linalg.triangular_solve"
-  }
-  endpoint {
-    name: "matrix_triangular_solve"
-  }
-}
-op {
-  graph_op_name: "Max"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MaxPool"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MaxPool3DGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MaxPool3DGradGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MaxPoolGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MaxPoolGradGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MaxPoolGradGradWithArgmax"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MaxPoolGradWithArgmax"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MaxPoolV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MaxPoolWithArgmax"
-  endpoint {
-    name: "nn.max_pool_with_argmax"
-  }
-}
-op {
-  graph_op_name: "Mean"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Merge"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MergeSummary"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Min"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MirrorPad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MirrorPadGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Mul"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MutableDenseHashTable"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MutableDenseHashTableV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MutableHashTable"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MutableHashTableOfTensors"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MutableHashTableOfTensorsV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "MutableHashTableV2"
-  visibility: HIDDEN
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_MatMul.pbtxt b/tensorflow/core/api_def/python_api/api_def_MatMul.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ce95f857beaae60404965e64afe04e086ee9ae32
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MatMul.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MatMul"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MatrixBandPart.pbtxt b/tensorflow/core/api_def/python_api/api_def_MatrixBandPart.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..89b1c1f5a92995c3ef0f86c021e309d8acb91e40
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MatrixBandPart.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "MatrixBandPart"
+  endpoint {
+    name: "linalg.band_part"
+  }
+  endpoint {
+    name: "matrix_band_part"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MatrixDeterminant.pbtxt b/tensorflow/core/api_def/python_api/api_def_MatrixDeterminant.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4d289f542f3cafad4e5a3a2f2c5e8dbb43b1ccaa
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MatrixDeterminant.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "MatrixDeterminant"
+  endpoint {
+    name: "linalg.det"
+  }
+  endpoint {
+    name: "matrix_determinant"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MatrixDiag.pbtxt b/tensorflow/core/api_def/python_api/api_def_MatrixDiag.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fd9d34635e1409e8885e5c243b521f352bb2f852
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MatrixDiag.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "MatrixDiag"
+  endpoint {
+    name: "linalg.diag"
+  }
+  endpoint {
+    name: "matrix_diag"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MatrixDiagPart.pbtxt b/tensorflow/core/api_def/python_api/api_def_MatrixDiagPart.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fa5d1f10af4626d0b33581ac284f68d9310cac1f
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MatrixDiagPart.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "MatrixDiagPart"
+  endpoint {
+    name: "linalg.diag_part"
+  }
+  endpoint {
+    name: "matrix_diag_part"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MatrixInverse.pbtxt b/tensorflow/core/api_def/python_api/api_def_MatrixInverse.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c0ddd73704f367ef069c2b970acbefd8d655e7c6
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MatrixInverse.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "MatrixInverse"
+  endpoint {
+    name: "linalg.inv"
+  }
+  endpoint {
+    name: "matrix_inverse"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MatrixSetDiag.pbtxt b/tensorflow/core/api_def/python_api/api_def_MatrixSetDiag.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..01f4f0e89d3c027e4a8c1325f457c04488532f04
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MatrixSetDiag.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "MatrixSetDiag"
+  endpoint {
+    name: "linalg.set_diag"
+  }
+  endpoint {
+    name: "matrix_set_diag"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MatrixSolve.pbtxt b/tensorflow/core/api_def/python_api/api_def_MatrixSolve.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cef763e4e9a1d11201bdcb9a573ddf5d64841e90
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MatrixSolve.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "MatrixSolve"
+  endpoint {
+    name: "linalg.solve"
+  }
+  endpoint {
+    name: "matrix_solve"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MatrixSolveLs.pbtxt b/tensorflow/core/api_def/python_api/api_def_MatrixSolveLs.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f981161d496070f2f15a63e805dd10c87667bdf5
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MatrixSolveLs.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MatrixSolveLs"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MatrixTriangularSolve.pbtxt b/tensorflow/core/api_def/python_api/api_def_MatrixTriangularSolve.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a0d576aa31bc72c45bf5f1433f4ec3392816e52b
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MatrixTriangularSolve.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "MatrixTriangularSolve"
+  endpoint {
+    name: "linalg.triangular_solve"
+  }
+  endpoint {
+    name: "matrix_triangular_solve"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Max.pbtxt b/tensorflow/core/api_def/python_api/api_def_Max.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bc369ea6182a829a233a75b2af8dd628346a886a
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Max.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Max"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MaxPool.pbtxt b/tensorflow/core/api_def/python_api/api_def_MaxPool.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e9712911c3442f14e211d27e3087d63f3fbc0f2e
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MaxPool.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MaxPool"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MaxPool3DGrad.pbtxt b/tensorflow/core/api_def/python_api/api_def_MaxPool3DGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..315c5dfa8279189cb0dd7ad6bedfb6905aeafb91
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MaxPool3DGrad.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MaxPool3DGrad"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MaxPool3DGradGrad.pbtxt b/tensorflow/core/api_def/python_api/api_def_MaxPool3DGradGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..81f06ce4fb6e54fd3ef3971c9bdef5a2a7be15eb
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MaxPool3DGradGrad.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MaxPool3DGradGrad"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MaxPoolGradGrad.pbtxt b/tensorflow/core/api_def/python_api/api_def_MaxPoolGradGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8ec9357bd299150d7f728631e86ec2fba4c2fc97
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MaxPoolGradGrad.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MaxPoolGradGrad"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MaxPoolGradGradWithArgmax.pbtxt b/tensorflow/core/api_def/python_api/api_def_MaxPoolGradGradWithArgmax.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..25ec5a41212c6dac2e0b82881e304e532bf7126a
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MaxPoolGradGradWithArgmax.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MaxPoolGradGradWithArgmax"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MaxPoolV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_MaxPoolV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0999b80d7b60b4defecb076cd3db0eec56e16583
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MaxPoolV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MaxPoolV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MaxPoolWithArgmax.pbtxt b/tensorflow/core/api_def/python_api/api_def_MaxPoolWithArgmax.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7d8abca5f1ad76df62e78f9d7228b586dce31bf6
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MaxPoolWithArgmax.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "MaxPoolWithArgmax"
+  endpoint {
+    name: "nn.max_pool_with_argmax"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Mean.pbtxt b/tensorflow/core/api_def/python_api/api_def_Mean.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b4aa5d8582a522536365bcb1db6654a4feb695d4
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Mean.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Mean"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Merge.pbtxt b/tensorflow/core/api_def/python_api/api_def_Merge.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..059c3d127a64a38ed92755ee0034871ad61bd615
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Merge.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Merge"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MergeSummary.pbtxt b/tensorflow/core/api_def/python_api/api_def_MergeSummary.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..72095c5f91f7c37a0967a01ce5a8b409227a8bad
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MergeSummary.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MergeSummary"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Min.pbtxt b/tensorflow/core/api_def/python_api/api_def_Min.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8172b4f6df77de3d233c669b695f672c98e9083a
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Min.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Min"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MirrorPad.pbtxt b/tensorflow/core/api_def/python_api/api_def_MirrorPad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..67aebb8e862533397190ac2f735314da960cd2e6
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MirrorPad.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MirrorPad"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Mul.pbtxt b/tensorflow/core/api_def/python_api/api_def_Mul.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fd08acd75206f6ab405edabf70181a0c57be74d9
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Mul.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Mul"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MutableDenseHashTable.pbtxt b/tensorflow/core/api_def/python_api/api_def_MutableDenseHashTable.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0c3921654e55b0dadf66f8de5cba46fbdd35276a
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MutableDenseHashTable.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MutableDenseHashTable"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MutableDenseHashTableV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_MutableDenseHashTableV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3aa6f690966ad10b93cdb5d449950f79c1484727
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MutableDenseHashTableV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MutableDenseHashTableV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MutableHashTable.pbtxt b/tensorflow/core/api_def/python_api/api_def_MutableHashTable.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d4566b96bd49da52415ca2e92fd00db6acf76e4d
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MutableHashTable.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MutableHashTable"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MutableHashTableOfTensors.pbtxt b/tensorflow/core/api_def/python_api/api_def_MutableHashTableOfTensors.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..aad491fd453abab80976acc393052ae2c954b105
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MutableHashTableOfTensors.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MutableHashTableOfTensors"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MutableHashTableOfTensorsV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_MutableHashTableOfTensorsV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..133ae60428ee03a8e860d4653ae4c9bbe1e1bc10
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MutableHashTableOfTensorsV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MutableHashTableOfTensorsV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_MutableHashTableV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_MutableHashTableV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1f7be9df100db6823b6851e29ae7f030a9a95a1d
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_MutableHashTableV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "MutableHashTableV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_N.pbtxt b/tensorflow/core/api_def/python_api/api_def_N.pbtxt
deleted file mode 100644
index 60da4dcafe886bafa44301cdf3c375551530fdea..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/python_api/api_def_N.pbtxt
+++ /dev/null
@@ -1,16 +0,0 @@
-op {
-  graph_op_name: "Neg"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "NegTrain"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "NonMaxSuppression"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "NonMaxSuppressionV2"
-  visibility: HIDDEN
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_Neg.pbtxt b/tensorflow/core/api_def/python_api/api_def_Neg.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0e2bb9b950d933f2e73272b403fba2c29110b3cb
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Neg.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Neg"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_NegTrain.pbtxt b/tensorflow/core/api_def/python_api/api_def_NegTrain.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0d536b4eaa52d624526e5e82aeed240436f83385
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_NegTrain.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "NegTrain"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_NonMaxSuppression.pbtxt b/tensorflow/core/api_def/python_api/api_def_NonMaxSuppression.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cdd122dc2b1e996458e9b802a4439c91fe1ffc66
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_NonMaxSuppression.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "NonMaxSuppression"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_NonMaxSuppressionV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_NonMaxSuppressionV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ddbf2ec74e22db9285b73dc38b6cbfc95835edae
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_NonMaxSuppressionV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "NonMaxSuppressionV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_O.pbtxt b/tensorflow/core/api_def/python_api/api_def_OneHot.pbtxt
similarity index 100%
rename from tensorflow/core/api_def/python_api/api_def_O.pbtxt
rename to tensorflow/core/api_def/python_api/api_def_OneHot.pbtxt
diff --git a/tensorflow/core/api_def/python_api/api_def_P.pbtxt b/tensorflow/core/api_def/python_api/api_def_P.pbtxt
deleted file mode 100644
index 87ca53e0b9a49e50f1937ff077b0129343ad7c42..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/python_api/api_def_P.pbtxt
+++ /dev/null
@@ -1,68 +0,0 @@
-op {
-  graph_op_name: "Pack"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Pad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "PadV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "PaddingFIFOQueue"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "PaddingFIFOQueueV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ParallelConcat"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ParameterizedTruncatedNormal"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ParseExample"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ParseSingleSequenceExample"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Placeholder"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Pow"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Print"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "PriorityQueue"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "PriorityQueueV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Prod"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "PyFunc"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "PyFuncStateless"
-  visibility: HIDDEN
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_Pack.pbtxt b/tensorflow/core/api_def/python_api/api_def_Pack.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cf7929e49a9a9fa01c217bf4f9a74aec6b924411
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Pack.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Pack"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Pad.pbtxt b/tensorflow/core/api_def/python_api/api_def_Pad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f9c04ee59b3b2c067ecc1634689eef0c3f0604a1
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Pad.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Pad"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_PadV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_PadV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e580992fb25cef38f9068a4667d1ce8cd782c96c
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_PadV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "PadV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_PaddingFIFOQueue.pbtxt b/tensorflow/core/api_def/python_api/api_def_PaddingFIFOQueue.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..575392b8b21f6b05ac882cac7fdfda27402d46ae
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_PaddingFIFOQueue.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "PaddingFIFOQueue"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_PaddingFIFOQueueV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_PaddingFIFOQueueV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b37b4162c8fa8c04c61285303a9b0101dcfb6cf0
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_PaddingFIFOQueueV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "PaddingFIFOQueueV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ParallelConcat.pbtxt b/tensorflow/core/api_def/python_api/api_def_ParallelConcat.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8117b085be638df6751e18ed4e40b45cbf60ae27
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ParallelConcat.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ParallelConcat"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ParameterizedTruncatedNormal.pbtxt b/tensorflow/core/api_def/python_api/api_def_ParameterizedTruncatedNormal.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..75444351fab7b40c407ad89618ea63279cef0e35
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ParameterizedTruncatedNormal.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ParameterizedTruncatedNormal"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ParseExample.pbtxt b/tensorflow/core/api_def/python_api/api_def_ParseExample.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c68a58d311ac2a61267aec0a61c59ec95b8b9dfd
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ParseExample.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ParseExample"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ParseSingleSequenceExample.pbtxt b/tensorflow/core/api_def/python_api/api_def_ParseSingleSequenceExample.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5b47f452dd058026f12647e200b9bb59cc9dbab7
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ParseSingleSequenceExample.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ParseSingleSequenceExample"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Placeholder.pbtxt b/tensorflow/core/api_def/python_api/api_def_Placeholder.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8c70d9cfe011c871721090a7fc4aca8b982ef5dc
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Placeholder.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Placeholder"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Pow.pbtxt b/tensorflow/core/api_def/python_api/api_def_Pow.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bee695149ad0fcc65a51aa06e3ae281a94ff6c6b
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Pow.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Pow"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Print.pbtxt b/tensorflow/core/api_def/python_api/api_def_Print.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7854d4c7276f14cd56f77a7bb3f2b20d7f3326af
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Print.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Print"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_PriorityQueue.pbtxt b/tensorflow/core/api_def/python_api/api_def_PriorityQueue.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..96d0e9bedc4cbf7eb36213539ebc150798d050b6
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_PriorityQueue.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "PriorityQueue"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_PriorityQueueV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_PriorityQueueV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f640692ff822b9764a3b53ee7dcadcc3d220e991
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_PriorityQueueV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "PriorityQueueV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Prod.pbtxt b/tensorflow/core/api_def/python_api/api_def_Prod.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9801fc0f054fcab3443b12b2ed8e663180642b7d
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Prod.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Prod"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_PyFunc.pbtxt b/tensorflow/core/api_def/python_api/api_def_PyFunc.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..df9e876f2bbd6addf7c018ead4783ee8b506e685
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_PyFunc.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "PyFunc"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_PyFuncStateless.pbtxt b/tensorflow/core/api_def/python_api/api_def_PyFuncStateless.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..50c8d1a096c52733ccf352a8f552f6573f07bbb9
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_PyFuncStateless.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "PyFuncStateless"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Q.pbtxt b/tensorflow/core/api_def/python_api/api_def_Q.pbtxt
deleted file mode 100644
index 0dfb5bb703bba7cb7576f48b112d3014d69c2824..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/python_api/api_def_Q.pbtxt
+++ /dev/null
@@ -1,83 +0,0 @@
-op {
-  graph_op_name: "Qr"
-  endpoint {
-    name: "linalg.qr"
-  }
-  endpoint {
-    name: "qr"
-  }
-}
-op {
-  graph_op_name: "QuantizedAvgPool"
-  endpoint {
-    name: "nn.quantized_avg_pool"
-  }
-}
-op {
-  graph_op_name: "QuantizedMaxPool"
-  endpoint {
-    name: "nn.quantized_max_pool"
-  }
-}
-op {
-  graph_op_name: "QuantizedReluX"
-  endpoint {
-    name: "nn.quantized_relu_x"
-  }
-}
-op {
-  graph_op_name: "QueueClose"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "QueueCloseV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "QueueDequeue"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "QueueDequeueMany"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "QueueDequeueManyV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "QueueDequeueUpTo"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "QueueDequeueUpToV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "QueueDequeueV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "QueueEnqueue"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "QueueEnqueueMany"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "QueueEnqueueManyV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "QueueEnqueueV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "QueueSize"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "QueueSizeV2"
-  visibility: HIDDEN
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_Qr.pbtxt b/tensorflow/core/api_def/python_api/api_def_Qr.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b19da0d8176d90ae32830359e6608f21d592e4de
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Qr.pbtxt
@@ -0,0 +1,9 @@
+op {
+  graph_op_name: "Qr"
+  endpoint {
+    name: "linalg.qr"
+  }
+  endpoint {
+    name: "qr"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_QuantizedAvgPool.pbtxt b/tensorflow/core/api_def/python_api/api_def_QuantizedAvgPool.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..dfa793a16e18ab30891bcb9a997d7bed02410e54
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_QuantizedAvgPool.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "QuantizedAvgPool"
+  endpoint {
+    name: "nn.quantized_avg_pool"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_QuantizedMaxPool.pbtxt b/tensorflow/core/api_def/python_api/api_def_QuantizedMaxPool.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3a58590f5773a3d886ace95108ee63a659362de2
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_QuantizedMaxPool.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "QuantizedMaxPool"
+  endpoint {
+    name: "nn.quantized_max_pool"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_QuantizedReluX.pbtxt b/tensorflow/core/api_def/python_api/api_def_QuantizedReluX.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..926ec98eeb468e7fa4846ae013a112cc865bb82c
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_QuantizedReluX.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "QuantizedReluX"
+  endpoint {
+    name: "nn.quantized_relu_x"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_QueueClose.pbtxt b/tensorflow/core/api_def/python_api/api_def_QueueClose.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7ab6f2f821ab22662a77ed995e51a12c1d30a183
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_QueueClose.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "QueueClose"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_QueueCloseV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_QueueCloseV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0a00c3d78ad3afe8a2abb39ac646504c2427ca60
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_QueueCloseV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "QueueCloseV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_QueueDequeue.pbtxt b/tensorflow/core/api_def/python_api/api_def_QueueDequeue.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ad2e246e92da4247d8f9d40259f3eb791aa4a2f8
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_QueueDequeue.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "QueueDequeue"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_QueueDequeueMany.pbtxt b/tensorflow/core/api_def/python_api/api_def_QueueDequeueMany.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ff6a6e47a4aafa0e26eb45b7eed8123cfdef86a5
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_QueueDequeueMany.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "QueueDequeueMany"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_QueueDequeueManyV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_QueueDequeueManyV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..30ed19a2106f1deb2af0b214c334ead9b48bc208
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_QueueDequeueManyV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "QueueDequeueManyV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_QueueDequeueUpTo.pbtxt b/tensorflow/core/api_def/python_api/api_def_QueueDequeueUpTo.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..34b59952a2124b4303a50a5773d6fdd7d1460094
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_QueueDequeueUpTo.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "QueueDequeueUpTo"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_QueueDequeueUpToV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_QueueDequeueUpToV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fd0cd2500dfefefe043ffb3c107c362507e25fc3
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_QueueDequeueUpToV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "QueueDequeueUpToV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_QueueDequeueV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_QueueDequeueV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3dfa758f1e2debd1fc4604269bcb0fd1c8037c0a
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_QueueDequeueV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "QueueDequeueV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_QueueEnqueue.pbtxt b/tensorflow/core/api_def/python_api/api_def_QueueEnqueue.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0a3698fd30586b1f3c2af9530cf1776760dbd28f
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_QueueEnqueue.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "QueueEnqueue"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_QueueEnqueueMany.pbtxt b/tensorflow/core/api_def/python_api/api_def_QueueEnqueueMany.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a6bab13c9d981018e6cb2a0f4032dbbee94c2aa5
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_QueueEnqueueMany.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "QueueEnqueueMany"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_QueueEnqueueManyV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_QueueEnqueueManyV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a70b2019a530fc82d82098a76bc511fe91ecf518
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_QueueEnqueueManyV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "QueueEnqueueManyV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_QueueEnqueueV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_QueueEnqueueV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a06d0a38563f8f539475275a8c97e96b40938620
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_QueueEnqueueV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "QueueEnqueueV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_QueueSize.pbtxt b/tensorflow/core/api_def/python_api/api_def_QueueSize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..25e881d381e9497cff4dbcf88517614f4c6e129f
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_QueueSize.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "QueueSize"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_QueueSizeV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_QueueSizeV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b33b4e804a58c9859a81bc53adff3d1dd8507cb3
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_QueueSizeV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "QueueSizeV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_R.pbtxt b/tensorflow/core/api_def/python_api/api_def_R.pbtxt
deleted file mode 100644
index 0c8a8a4d4235ebe86a45d66d32dc307329d3f5ed..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/python_api/api_def_R.pbtxt
+++ /dev/null
@@ -1,192 +0,0 @@
-op {
-  graph_op_name: "RGBToHSV"
-  endpoint {
-    name: "image.rgb_to_hsv"
-  }
-}
-op {
-  graph_op_name: "RandomCrop"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "RandomGamma"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "RandomPoisson"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "RandomShuffle"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "RandomShuffleQueue"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "RandomShuffleQueueV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "RandomStandardNormal"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "RandomUniform"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "RandomUniformInt"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Range"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ReaderNumRecordsProduced"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ReaderNumRecordsProducedV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ReaderNumWorkUnitsCompleted"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ReaderNumWorkUnitsCompletedV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ReaderRead"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ReaderReadUpTo"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ReaderReadUpToV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ReaderReadV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ReaderReset"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ReaderResetV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ReaderRestoreState"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ReaderRestoreStateV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ReaderSerializeState"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ReaderSerializeStateV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "RealDiv"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ReciprocalGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "RefExit"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "RefIdentity"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "RefMerge"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Relu"
-  endpoint {
-    name: "nn.relu"
-  }
-}
-op {
-  graph_op_name: "Relu6"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Relu6Grad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ReluGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ResizeArea"
-  endpoint {
-    name: "image.resize_area"
-  }
-}
-op {
-  graph_op_name: "ResizeBicubic"
-  endpoint {
-    name: "image.resize_bicubic"
-  }
-}
-op {
-  graph_op_name: "ResizeBicubicGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ResizeBilinear"
-  endpoint {
-    name: "image.resize_bilinear"
-  }
-}
-op {
-  graph_op_name: "ResizeBilinearGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ResizeNearestNeighbor"
-  endpoint {
-    name: "image.resize_nearest_neighbor"
-  }
-}
-op {
-  graph_op_name: "ResizeNearestNeighborGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Restore"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "RestoreSlice"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Reverse"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "RsqrtGrad"
-  visibility: HIDDEN
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_RGBToHSV.pbtxt b/tensorflow/core/api_def/python_api/api_def_RGBToHSV.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5676391e19547bb3c80304b0fdc6459acbc500f1
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_RGBToHSV.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "RGBToHSV"
+  endpoint {
+    name: "image.rgb_to_hsv"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_RandomCrop.pbtxt b/tensorflow/core/api_def/python_api/api_def_RandomCrop.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f2da1712a20ca2f0d06e623d194c558b1fc75894
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_RandomCrop.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "RandomCrop"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_RandomGamma.pbtxt b/tensorflow/core/api_def/python_api/api_def_RandomGamma.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..23509d8d61743749c741abb40450e0ccf17e2e8f
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_RandomGamma.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "RandomGamma"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_RandomPoisson.pbtxt b/tensorflow/core/api_def/python_api/api_def_RandomPoisson.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a7da239cb668200ec7003baa274114bf35e076b2
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_RandomPoisson.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "RandomPoisson"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_RandomShuffle.pbtxt b/tensorflow/core/api_def/python_api/api_def_RandomShuffle.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4e265c8b4ee0eb01b2d802523f0a65fa6729a332
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_RandomShuffle.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "RandomShuffle"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_RandomShuffleQueue.pbtxt b/tensorflow/core/api_def/python_api/api_def_RandomShuffleQueue.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..be93d99e8483d9ec0c23e9793549b7a1f712aebf
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_RandomShuffleQueue.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "RandomShuffleQueue"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_RandomShuffleQueueV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_RandomShuffleQueueV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..afef0176820366018d0107f4dd5a108f8df502d7
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_RandomShuffleQueueV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "RandomShuffleQueueV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_RandomStandardNormal.pbtxt b/tensorflow/core/api_def/python_api/api_def_RandomStandardNormal.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3faff40d8ab4196ebb8b163becd154e1e148122a
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_RandomStandardNormal.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "RandomStandardNormal"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_RandomUniform.pbtxt b/tensorflow/core/api_def/python_api/api_def_RandomUniform.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b36975ca763dfa57b15ce2790bbbafb0cbb98f9b
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_RandomUniform.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "RandomUniform"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_RandomUniformInt.pbtxt b/tensorflow/core/api_def/python_api/api_def_RandomUniformInt.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c1da2952324896f7dcaee173469ed0eb354fef1f
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_RandomUniformInt.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "RandomUniformInt"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Range.pbtxt b/tensorflow/core/api_def/python_api/api_def_Range.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..48b0e9dda4a3e7b70af47aad356f2d0f0b96f325
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Range.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Range"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ReaderNumRecordsProduced.pbtxt b/tensorflow/core/api_def/python_api/api_def_ReaderNumRecordsProduced.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0849191a0c929f6cdb196f6cd676908d22dff0ac
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ReaderNumRecordsProduced.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ReaderNumRecordsProduced"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ReaderNumRecordsProducedV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_ReaderNumRecordsProducedV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ad4acb68bc4d8b8f0c3456718a9a6d27b3765c07
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ReaderNumRecordsProducedV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ReaderNumRecordsProducedV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ReaderNumWorkUnitsCompleted.pbtxt b/tensorflow/core/api_def/python_api/api_def_ReaderNumWorkUnitsCompleted.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..283d3ce1d496c7295a135e05e9de087585e84cc5
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ReaderNumWorkUnitsCompleted.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ReaderNumWorkUnitsCompleted"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ReaderNumWorkUnitsCompletedV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_ReaderNumWorkUnitsCompletedV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..94a1af49126ac98d819b63ab1067e18253a5fd65
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ReaderNumWorkUnitsCompletedV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ReaderNumWorkUnitsCompletedV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ReaderRead.pbtxt b/tensorflow/core/api_def/python_api/api_def_ReaderRead.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f0e248dfe4cfe6d23bf000083e247cdb88e8abd1
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ReaderRead.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ReaderRead"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ReaderReadUpTo.pbtxt b/tensorflow/core/api_def/python_api/api_def_ReaderReadUpTo.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5e2502b22e03978d797b9043526e4cf100393687
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ReaderReadUpTo.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ReaderReadUpTo"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ReaderReadUpToV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_ReaderReadUpToV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..43b375c69f6a887c7faece56b216f6b098607cf7
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ReaderReadUpToV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ReaderReadUpToV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ReaderReadV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_ReaderReadV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ef3500df063ea8a32f78312a7ee03c2134b7d34b
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ReaderReadV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ReaderReadV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ReaderReset.pbtxt b/tensorflow/core/api_def/python_api/api_def_ReaderReset.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..679b1caec047c574c76234ea825b595f73a4eab1
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ReaderReset.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ReaderReset"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ReaderResetV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_ReaderResetV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..59453c479c5a96a4fc394c357a7b24fc85ccd27b
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ReaderResetV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ReaderResetV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ReaderRestoreState.pbtxt b/tensorflow/core/api_def/python_api/api_def_ReaderRestoreState.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3075388c62d4eabd05f8332770c236fb36d6c7ea
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ReaderRestoreState.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ReaderRestoreState"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ReaderRestoreStateV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_ReaderRestoreStateV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0edc9e2f24869d0e7700d9cc2a3bfc5133cbd1b4
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ReaderRestoreStateV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ReaderRestoreStateV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ReaderSerializeState.pbtxt b/tensorflow/core/api_def/python_api/api_def_ReaderSerializeState.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b766ce93af3d96282c0c56ed2026cc52c23e740e
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ReaderSerializeState.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ReaderSerializeState"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ReaderSerializeStateV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_ReaderSerializeStateV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9e1247eec60b331550083ed8bd8e2fa914d8153c
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ReaderSerializeStateV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ReaderSerializeStateV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_RealDiv.pbtxt b/tensorflow/core/api_def/python_api/api_def_RealDiv.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bd87eef8240532c158b7604d8c5576e6d0b8b24b
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_RealDiv.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "RealDiv"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Relu.pbtxt b/tensorflow/core/api_def/python_api/api_def_Relu.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..64c61f4ecf450957e518944b748a038c189d2750
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Relu.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "Relu"
+  endpoint {
+    name: "nn.relu"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Relu6.pbtxt b/tensorflow/core/api_def/python_api/api_def_Relu6.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8a132abdf391a675bbb88656a18c09250e3e22d7
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Relu6.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Relu6"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ResizeArea.pbtxt b/tensorflow/core/api_def/python_api/api_def_ResizeArea.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2f1b4aee00d90221d659daa34a7eb3462f42fa0c
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ResizeArea.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "ResizeArea"
+  endpoint {
+    name: "image.resize_area"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ResizeBicubic.pbtxt b/tensorflow/core/api_def/python_api/api_def_ResizeBicubic.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3ec8e0ad6359307eab1b166801474817d8c5282b
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ResizeBicubic.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "ResizeBicubic"
+  endpoint {
+    name: "image.resize_bicubic"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ResizeBilinear.pbtxt b/tensorflow/core/api_def/python_api/api_def_ResizeBilinear.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..eb3b8d6f458fff6163932457ef6c73a8fbbd721e
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ResizeBilinear.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "ResizeBilinear"
+  endpoint {
+    name: "image.resize_bilinear"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ResizeNearestNeighbor.pbtxt b/tensorflow/core/api_def/python_api/api_def_ResizeNearestNeighbor.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..25c5d5701feefd6f8270236f29e1c187fa3cf06a
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ResizeNearestNeighbor.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "ResizeNearestNeighbor"
+  endpoint {
+    name: "image.resize_nearest_neighbor"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Restore.pbtxt b/tensorflow/core/api_def/python_api/api_def_Restore.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2ec456467df8921634a44f82fccda6994ef72f5c
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Restore.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Restore"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_RestoreSlice.pbtxt b/tensorflow/core/api_def/python_api/api_def_RestoreSlice.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f188a291e6d9066a851ecc1779dcc01c2f82a64c
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_RestoreSlice.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "RestoreSlice"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Reverse.pbtxt b/tensorflow/core/api_def/python_api/api_def_Reverse.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e2cad1a557b7eda2c3a78ab4de1052c65a749791
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Reverse.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Reverse"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ReverseV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_ReverseV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8307a3c2dddd0891f21534d12e2beed19b70b552
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ReverseV2.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "ReverseV2"
+  endpoint {
+    name: "reverse_v2"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_RightShift.pbtxt b/tensorflow/core/api_def/python_api/api_def_RightShift.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4d82c3d7e7a6adaea6f0d41521d8bf9a3e20222d
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_RightShift.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "RightShift"
+  endpoint {
+    name: "bitwise.right_shift"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_S.pbtxt b/tensorflow/core/api_def/python_api/api_def_S.pbtxt
deleted file mode 100644
index 0c34730200c88a0c75cd4cb11f3cf8f177583417..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/python_api/api_def_S.pbtxt
+++ /dev/null
@@ -1,252 +0,0 @@
-op {
-  graph_op_name: "SampleDistortedBoundingBox"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SampleDistortedBoundingBoxV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Save"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SaveSlices"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ScalarSummary"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SdcaFprint"
-  endpoint {
-    name: "train.sdca_fprint"
-  }
-}
-op {
-  graph_op_name: "SdcaOptimizer"
-  endpoint {
-    name: "train.sdca_optimizer"
-  }
-}
-op {
-  graph_op_name: "SdcaShrinkL1"
-  endpoint {
-    name: "train.sdca_shrink_l1"
-  }
-}
-op {
-  graph_op_name: "Select"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SelfAdjointEig"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SelfAdjointEigV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Selu"
-  endpoint {
-    name: "nn.selu"
-  }
-}
-op {
-  graph_op_name: "SeluGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SerializeManySparse"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SerializeSparse"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ShardedFilename"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ShardedFilespec"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Sigmoid"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SigmoidGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Skipgram"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Slice"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Softmax"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SoftmaxCrossEntropyWithLogits"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Softplus"
-  endpoint {
-    name: "nn.softplus"
-  }
-}
-op {
-  graph_op_name: "SoftplusGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Softsign"
-  endpoint {
-    name: "nn.softsign"
-  }
-}
-op {
-  graph_op_name: "SoftsignGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SpaceToBatch"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SparseAdd"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SparseAddGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SparseConcat"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SparseCross"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SparseFillEmptyRows"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SparseFillEmptyRowsGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SparseMatMul"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SparseReorder"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SparseReshape"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SparseSoftmaxCrossEntropyWithLogits"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SparseSplit"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SparseTensorDenseAdd"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SparseTensorDenseMatMul"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SparseToDense"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Split"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SplitV"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SqrtGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Squeeze"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Stack"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "StackClose"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "StackCloseV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "StackPop"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "StackPopV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "StackPush"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "StackPushV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "StackV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "StringSplit"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Sub"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Sum"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Svd"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Switch"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "SymbolicGradient"
-  visibility: HIDDEN
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_SampleDistortedBoundingBox.pbtxt b/tensorflow/core/api_def/python_api/api_def_SampleDistortedBoundingBox.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..20a155bd5fdf6334d414fc6933e1e80a55a06067
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SampleDistortedBoundingBox.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SampleDistortedBoundingBox"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SampleDistortedBoundingBoxV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_SampleDistortedBoundingBoxV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cdd0797f6d42f1ae1a9cb3d268b17030b5ce54a8
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SampleDistortedBoundingBoxV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SampleDistortedBoundingBoxV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Save.pbtxt b/tensorflow/core/api_def/python_api/api_def_Save.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e43730f6ff97b376270d2bf73abeff76029813ce
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Save.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Save"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SaveSlices.pbtxt b/tensorflow/core/api_def/python_api/api_def_SaveSlices.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5861c84b275f478bb2d0312c0a86cd1184812f72
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SaveSlices.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SaveSlices"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ScalarSummary.pbtxt b/tensorflow/core/api_def/python_api/api_def_ScalarSummary.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f4009af08c12c576f26c334ce5516f19ac9d3ce7
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ScalarSummary.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ScalarSummary"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SdcaFprint.pbtxt b/tensorflow/core/api_def/python_api/api_def_SdcaFprint.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..60e249077f26da7dd507fa67a8c1810a9d71d195
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SdcaFprint.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "SdcaFprint"
+  endpoint {
+    name: "train.sdca_fprint"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SdcaOptimizer.pbtxt b/tensorflow/core/api_def/python_api/api_def_SdcaOptimizer.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5e8e95ee9d9785f640d9ed807eec1bbdafe7d380
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SdcaOptimizer.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "SdcaOptimizer"
+  endpoint {
+    name: "train.sdca_optimizer"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SdcaShrinkL1.pbtxt b/tensorflow/core/api_def/python_api/api_def_SdcaShrinkL1.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..552a91fb7ef4cb9801377e01d3ce1390eac37af2
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SdcaShrinkL1.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "SdcaShrinkL1"
+  endpoint {
+    name: "train.sdca_shrink_l1"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Select.pbtxt b/tensorflow/core/api_def/python_api/api_def_Select.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6e0f3dc4a23ac4d2afef9c573af0149f836c37d5
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Select.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Select"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SelfAdjointEig.pbtxt b/tensorflow/core/api_def/python_api/api_def_SelfAdjointEig.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..febe9f2f5ac54ec05c433edca50a3bcc0fff3570
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SelfAdjointEig.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SelfAdjointEig"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SelfAdjointEigV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_SelfAdjointEigV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b9f3274882a582feb0c4889fef944ecda0479b7b
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SelfAdjointEigV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SelfAdjointEigV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Selu.pbtxt b/tensorflow/core/api_def/python_api/api_def_Selu.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..da9ad7ce3442fdc0031629332131323da2ed0fc7
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Selu.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "Selu"
+  endpoint {
+    name: "nn.selu"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SerializeManySparse.pbtxt b/tensorflow/core/api_def/python_api/api_def_SerializeManySparse.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b965a3ad4312fabcbc5a0038c583484f9253c217
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SerializeManySparse.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SerializeManySparse"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SerializeSparse.pbtxt b/tensorflow/core/api_def/python_api/api_def_SerializeSparse.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fe95f20302331ec2348cfc5d0ba83dc47a19ad41
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SerializeSparse.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SerializeSparse"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ShardedFilename.pbtxt b/tensorflow/core/api_def/python_api/api_def_ShardedFilename.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..67b2ef6bfc8b66cd8ef435ec1718fd522ae81950
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ShardedFilename.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ShardedFilename"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ShardedFilespec.pbtxt b/tensorflow/core/api_def/python_api/api_def_ShardedFilespec.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bb25f103f17114c53c6cdae57d6747e193dff402
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ShardedFilespec.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ShardedFilespec"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Sigmoid.pbtxt b/tensorflow/core/api_def/python_api/api_def_Sigmoid.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4a6ffb7198aba8d341a74ef030dc2fe570da4faa
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Sigmoid.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Sigmoid"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Skipgram.pbtxt b/tensorflow/core/api_def/python_api/api_def_Skipgram.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2bc76069f218f70dcff0e3ea24755e6f19812587
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Skipgram.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Skipgram"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Slice.pbtxt b/tensorflow/core/api_def/python_api/api_def_Slice.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..12e7dcc20340e3af92bc437483d88458446aab3e
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Slice.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Slice"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Softmax.pbtxt b/tensorflow/core/api_def/python_api/api_def_Softmax.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d8605c8ddd9540862287ef647a5aec701716f008
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Softmax.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Softmax"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SoftmaxCrossEntropyWithLogits.pbtxt b/tensorflow/core/api_def/python_api/api_def_SoftmaxCrossEntropyWithLogits.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e30b5a4821d167056cb15bbe1c5fd35f2b3879c5
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SoftmaxCrossEntropyWithLogits.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SoftmaxCrossEntropyWithLogits"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Softplus.pbtxt b/tensorflow/core/api_def/python_api/api_def_Softplus.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2de56c27be2b5535fbb54cbab9c7004b9f0c2e27
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Softplus.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "Softplus"
+  endpoint {
+    name: "nn.softplus"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Softsign.pbtxt b/tensorflow/core/api_def/python_api/api_def_Softsign.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b47412d1356ab76b83da048e4880126229146692
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Softsign.pbtxt
@@ -0,0 +1,6 @@
+op {
+  graph_op_name: "Softsign"
+  endpoint {
+    name: "nn.softsign"
+  }
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SpaceToBatch.pbtxt b/tensorflow/core/api_def/python_api/api_def_SpaceToBatch.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2a26f9a3ec47f625f3f5796bcc55f47caed4b8d9
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SpaceToBatch.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SpaceToBatch"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SparseAdd.pbtxt b/tensorflow/core/api_def/python_api/api_def_SparseAdd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6de974fd274231468e84a4eeb155631b250fb4a0
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SparseAdd.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SparseAdd"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SparseAddGrad.pbtxt b/tensorflow/core/api_def/python_api/api_def_SparseAddGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..87c306aaccb0123a60965dc92ebd370d206738ef
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SparseAddGrad.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SparseAddGrad"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SparseConcat.pbtxt b/tensorflow/core/api_def/python_api/api_def_SparseConcat.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3bae51fe23aa3a6092602f66027c95a6c98b2eb9
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SparseConcat.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SparseConcat"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SparseCross.pbtxt b/tensorflow/core/api_def/python_api/api_def_SparseCross.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..25506cbb31539bef61fafcecf9dc7d0ac74e7993
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SparseCross.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SparseCross"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SparseFillEmptyRows.pbtxt b/tensorflow/core/api_def/python_api/api_def_SparseFillEmptyRows.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..242e87af1ef519a4c033073789f9b002fcf4b1c2
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SparseFillEmptyRows.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SparseFillEmptyRows"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SparseFillEmptyRowsGrad.pbtxt b/tensorflow/core/api_def/python_api/api_def_SparseFillEmptyRowsGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1cb69c48040dc03a49167cc26e76efbb8fc11090
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SparseFillEmptyRowsGrad.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SparseFillEmptyRowsGrad"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SparseMatMul.pbtxt b/tensorflow/core/api_def/python_api/api_def_SparseMatMul.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f0af41dbdb3fd103d82187bb242f2732a49a43bf
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SparseMatMul.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SparseMatMul"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SparseReorder.pbtxt b/tensorflow/core/api_def/python_api/api_def_SparseReorder.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..18be89eff499c899911dc93de4bf3ef7ebb73000
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SparseReorder.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SparseReorder"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SparseReshape.pbtxt b/tensorflow/core/api_def/python_api/api_def_SparseReshape.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..010de3e4ad6d701905054183bf165e215c6c3b66
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SparseReshape.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SparseReshape"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SparseSoftmaxCrossEntropyWithLogits.pbtxt b/tensorflow/core/api_def/python_api/api_def_SparseSoftmaxCrossEntropyWithLogits.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..06e461aaa7c53045e78afdb4420280b75fdb2aa1
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SparseSoftmaxCrossEntropyWithLogits.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SparseSoftmaxCrossEntropyWithLogits"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SparseSplit.pbtxt b/tensorflow/core/api_def/python_api/api_def_SparseSplit.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..285fb96d45ed9d63c4c8ec6e01e885a27892f08c
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SparseSplit.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SparseSplit"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SparseTensorDenseAdd.pbtxt b/tensorflow/core/api_def/python_api/api_def_SparseTensorDenseAdd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9b4b6b92327b4ac7d121436cdb36d570adc7aba1
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SparseTensorDenseAdd.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SparseTensorDenseAdd"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SparseTensorDenseMatMul.pbtxt b/tensorflow/core/api_def/python_api/api_def_SparseTensorDenseMatMul.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..07878ed2e8be1166b567a07c9c3831e40557ce84
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SparseTensorDenseMatMul.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SparseTensorDenseMatMul"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SparseToDense.pbtxt b/tensorflow/core/api_def/python_api/api_def_SparseToDense.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8f5d6f1d96c592be9a2b87cfcb5fb59c5d813807
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SparseToDense.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SparseToDense"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Split.pbtxt b/tensorflow/core/api_def/python_api/api_def_Split.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..609fd3dc2aaa9e7c466c36b43c058012301a49c2
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Split.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Split"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SplitV.pbtxt b/tensorflow/core/api_def/python_api/api_def_SplitV.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0ae6f36d1c3ba75583cf6c44a21f8c58fa8a67d6
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SplitV.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SplitV"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Squeeze.pbtxt b/tensorflow/core/api_def/python_api/api_def_Squeeze.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..9f5697ca94efbe071aeff18eb7229c12fc374936
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Squeeze.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Squeeze"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Stack.pbtxt b/tensorflow/core/api_def/python_api/api_def_Stack.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..4ee4f6288b43019572d199554c7d2e245cf27009
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Stack.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Stack"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_StackClose.pbtxt b/tensorflow/core/api_def/python_api/api_def_StackClose.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..086acaa5341625465496d73a88c8840fbcd89a54
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_StackClose.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "StackClose"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_StackCloseV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_StackCloseV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e450ce00474ea02a0624b0a8c97c37bdd14f65eb
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_StackCloseV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "StackCloseV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_StackPop.pbtxt b/tensorflow/core/api_def/python_api/api_def_StackPop.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..59352ead760318e976a58135919b1198bca317ce
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_StackPop.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "StackPop"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_StackPopV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_StackPopV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..102fdd00b7889c7dfc0432b31e4788d4dab44ecb
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_StackPopV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "StackPopV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_StackPush.pbtxt b/tensorflow/core/api_def/python_api/api_def_StackPush.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a83c24909c2a04ce31e8baceeb81ac29b3721f08
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_StackPush.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "StackPush"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_StackPushV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_StackPushV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..fad442ada6c2f81e255374b22cc9a81f5616efe7
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_StackPushV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "StackPushV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_StackV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_StackV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..31362f46f7426fdd009cc60a1a90978fec502823
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_StackV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "StackV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_StringSplit.pbtxt b/tensorflow/core/api_def/python_api/api_def_StringSplit.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..891ff7157a4777def06f9340bb6bb550c80670ad
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_StringSplit.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "StringSplit"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Sub.pbtxt b/tensorflow/core/api_def/python_api/api_def_Sub.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..747b44d4feecd7f81886ed338658914694786230
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Sub.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Sub"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Sum.pbtxt b/tensorflow/core/api_def/python_api/api_def_Sum.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..68e34721814f947609388baa6aad1a50b2ec8d71
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Sum.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Sum"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Svd.pbtxt b/tensorflow/core/api_def/python_api/api_def_Svd.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..098180f8d906c239e55606208994dfa2ad39950a
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Svd.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Svd"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Switch.pbtxt b/tensorflow/core/api_def/python_api/api_def_Switch.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2087c860b425a84c6261e27e0f54c15812228ffc
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Switch.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Switch"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_SymbolicGradient.pbtxt b/tensorflow/core/api_def/python_api/api_def_SymbolicGradient.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0f747f464b8956a22db7beb795df439df3066e49
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_SymbolicGradient.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "SymbolicGradient"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_T.pbtxt b/tensorflow/core/api_def/python_api/api_def_T.pbtxt
deleted file mode 100644
index 8011a11243f307c4046aba376b39e34c53cd479a..0000000000000000000000000000000000000000
--- a/tensorflow/core/api_def/python_api/api_def_T.pbtxt
+++ /dev/null
@@ -1,196 +0,0 @@
-op {
-  graph_op_name: "TFRecordReader"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TFRecordReaderV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TakeManySparseFromTensorsMap"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "Tanh"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TanhGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TemporaryVariable"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArray"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayClose"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayCloseV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayCloseV3"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayConcat"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayConcatV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayConcatV3"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayGather"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayGatherV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayGatherV3"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayGradV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayGradV3"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayPack"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayRead"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayReadV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayReadV3"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayScatter"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayScatterV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayScatterV3"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArraySize"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArraySizeV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArraySizeV3"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArraySplit"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArraySplitV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArraySplitV3"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayUnpack"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayV3"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayWrite"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayWriteV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorArrayWriteV3"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorSummary"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TensorSummaryV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TextLineReader"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TextLineReaderV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "ThreadUnsafeUnigramCandidateSampler"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TileGrad"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TopK"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TopKV2"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TruncateDiv"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TruncateMod"
-  visibility: HIDDEN
-}
-op {
-  graph_op_name: "TruncatedNormal"
-  visibility: HIDDEN
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_TFRecordReader.pbtxt b/tensorflow/core/api_def/python_api/api_def_TFRecordReader.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1ec8bee340f3a825b23369e0bf87e6402308f763
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TFRecordReader.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TFRecordReader"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TFRecordReaderV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_TFRecordReaderV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e1cda01a6eea0d135c42370cdfe2551416da4fce
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TFRecordReaderV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TFRecordReaderV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TakeManySparseFromTensorsMap.pbtxt b/tensorflow/core/api_def/python_api/api_def_TakeManySparseFromTensorsMap.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..842419cc253c2699aeb79ff195d9f8dc9a5b31df
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TakeManySparseFromTensorsMap.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TakeManySparseFromTensorsMap"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Tanh.pbtxt b/tensorflow/core/api_def/python_api/api_def_Tanh.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..c946e0a794a77fe6f40613824e6d614e9667ccf9
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Tanh.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Tanh"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TemporaryVariable.pbtxt b/tensorflow/core/api_def/python_api/api_def_TemporaryVariable.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..a9201b4fec5c3e0095ad14df63c6359436654b93
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TemporaryVariable.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TemporaryVariable"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArray.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArray.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f7288b85d7ec3990d591e8db38aa018ed1e1dd25
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArray.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArray"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayClose.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayClose.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..73e208459c0c1b0cfa8fd28e73f2fcff4844a44e
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayClose.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayClose"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayCloseV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayCloseV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6c6955f8c7930d0c6da6672e62e3606dfee8748a
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayCloseV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayCloseV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayCloseV3.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayCloseV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d95854cefb984782d11b188a6b774aad1941536c
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayCloseV3.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayCloseV3"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayConcat.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayConcat.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..3695a787b98c9adae8f3a8b90946c6b1b68a2f9a
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayConcat.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayConcat"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayConcatV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayConcatV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..ac103d3c48611c89ba6da87740e78e16adbec887
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayConcatV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayConcatV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayConcatV3.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayConcatV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..54cdd3b949d112bde2494b5e299ae601cc44377f
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayConcatV3.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayConcatV3"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayGather.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayGather.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..82a98fe7f5b77815e2dcd5d1a94887421a9f2582
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayGather.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayGather"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayGatherV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayGatherV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b7fc8541ddb5baa2120c46493038d895f5fe6920
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayGatherV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayGatherV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayGatherV3.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayGatherV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..08dcedb8b7e19c7d244cad127fe6e75a8dd6e93b
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayGatherV3.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayGatherV3"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayGrad.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..04b614d22ca986cfcb42ac05095c95a024ae6af4
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayGrad.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayGrad"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayGradV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayGradV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..bf204dde364e4779d37e5c7c3b3ddb07a8f57b8f
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayGradV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayGradV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayGradV3.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayGradV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..75aaf6126eb9bb06a902e730e781f1db6381f9a3
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayGradV3.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayGradV3"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayPack.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayPack.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f60367c1fc92ec39871ed77645bc6f8756d3fc35
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayPack.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayPack"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayRead.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayRead.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e6c4ccdcf528747a0e9c88f7541c7f87f212a856
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayRead.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayRead"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayReadV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayReadV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..be19fe86fa46d83a722a422b357730a3873299c3
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayReadV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayReadV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayReadV3.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayReadV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d024f420bc97ca1db9f40de5b53b8988f5aa5e90
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayReadV3.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayReadV3"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayScatter.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayScatter.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8cdbb22af52d22e7c5cf83c0e732911003688304
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayScatter.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayScatter"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayScatterV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayScatterV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..02e16b14073b0f5d55e46398a380d57e695b1dae
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayScatterV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayScatterV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayScatterV3.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayScatterV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..8d262cc6653e6fea43c71656b081f820dd2c7fa0
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayScatterV3.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayScatterV3"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArraySize.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArraySize.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..169e495c4f9d1616be654861fe98640507513401
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArraySize.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArraySize"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArraySizeV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArraySizeV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d0dbd0d813a20d71f26ff9f62287253ca17fdc7f
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArraySizeV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArraySizeV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArraySizeV3.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArraySizeV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f4e656f5cc8c6e589d123ec145735a3c6dc20a5a
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArraySizeV3.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArraySizeV3"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArraySplit.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArraySplit.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1d9c53b2b455827f3b48c0087d81f5cf45a8c38e
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArraySplit.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArraySplit"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArraySplitV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArraySplitV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..502c78d83ecad1801c5a98fc47bf8d156e1198a8
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArraySplitV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArraySplitV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArraySplitV3.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArraySplitV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..faefa0fac25a6af5a3e6c399d5a996170cca1969
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArraySplitV3.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArraySplitV3"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayUnpack.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayUnpack.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..e5c0a794eb66eabc83e38be07d568a9d6e0b1548
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayUnpack.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayUnpack"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6ad5c5f288dfc17cb0f44cfbb32b51c31713414a
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayV3.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..da69f1513cd6f675fbfbac115340b0c0b7a7c795
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayV3.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayV3"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayWrite.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayWrite.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..58d50cb7f2c29947f8465371987079e8f6bc4646
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayWrite.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayWrite"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayWriteV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayWriteV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..f07bb3501784856a8e33e467d4d8f3e2fd819ebc
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayWriteV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayWriteV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorArrayWriteV3.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorArrayWriteV3.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..becc140401de536005572029a76a161864b48d4f
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorArrayWriteV3.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorArrayWriteV3"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorSummary.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorSummary.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b5148e5d0c88de0f168873ebb5237978e122d95b
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorSummary.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorSummary"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TensorSummaryV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_TensorSummaryV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6245bdce2b1215c0ebdcaffca1b46106c7413c86
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TensorSummaryV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TensorSummaryV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TextLineReader.pbtxt b/tensorflow/core/api_def/python_api/api_def_TextLineReader.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7fa1f6a441a72e5772824c8eca4b7cdc1cb31b4f
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TextLineReader.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TextLineReader"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TextLineReaderV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_TextLineReaderV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..cc506b39d6ef50b67cb5f01c7629d443e1cde6d6
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TextLineReaderV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TextLineReaderV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_ThreadUnsafeUnigramCandidateSampler.pbtxt b/tensorflow/core/api_def/python_api/api_def_ThreadUnsafeUnigramCandidateSampler.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7433d2f967b561514f2515fb270ec703c3f59711
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_ThreadUnsafeUnigramCandidateSampler.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "ThreadUnsafeUnigramCandidateSampler"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TileGrad.pbtxt b/tensorflow/core/api_def/python_api/api_def_TileGrad.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..1d2dce067bf8df0d3ffee97de949e8380f2f5c1c
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TileGrad.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TileGrad"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TopK.pbtxt b/tensorflow/core/api_def/python_api/api_def_TopK.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..85ebb650e0c12b035858437770ef657df29c061c
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TopK.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TopK"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TopKV2.pbtxt b/tensorflow/core/api_def/python_api/api_def_TopKV2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..671b04819ce40b04113af2e4b23d1ca78fc49d78
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TopKV2.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TopKV2"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TruncateDiv.pbtxt b/tensorflow/core/api_def/python_api/api_def_TruncateDiv.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..2a547f771cfb3d4f3d9496ea24196e1a8a1f1879
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TruncateDiv.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TruncateDiv"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TruncateMod.pbtxt b/tensorflow/core/api_def/python_api/api_def_TruncateMod.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..0731e8810e25cad2cca02522aba55d032b1765b2
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TruncateMod.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TruncateMod"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_TruncatedNormal.pbtxt b/tensorflow/core/api_def/python_api/api_def_TruncatedNormal.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..6003b2fdca1508c0b26e5232b0c1e648f636db73
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_TruncatedNormal.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "TruncatedNormal"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_U.pbtxt b/tensorflow/core/api_def/python_api/api_def_UniformCandidateSampler.pbtxt
similarity index 56%
rename from tensorflow/core/api_def/python_api/api_def_U.pbtxt
rename to tensorflow/core/api_def/python_api/api_def_UniformCandidateSampler.pbtxt
index d7c261c63c8dcc259b4d5e77f114dba746538f61..6a73062b0a07147179faf469d98ae6c2ea5555ba 100644
--- a/tensorflow/core/api_def/python_api/api_def_U.pbtxt
+++ b/tensorflow/core/api_def/python_api/api_def_UniformCandidateSampler.pbtxt
@@ -2,7 +2,3 @@ op {
   graph_op_name: "UniformCandidateSampler"
   visibility: HIDDEN
 }
-op {
-  graph_op_name: "Unpack"
-  visibility: HIDDEN
-}
diff --git a/tensorflow/core/api_def/python_api/api_def_Unpack.pbtxt b/tensorflow/core/api_def/python_api/api_def_Unpack.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..30d7b7f73471a9a48f595cf52c59c44653476c39
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Unpack.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Unpack"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_Variable.pbtxt b/tensorflow/core/api_def/python_api/api_def_Variable.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..7340d2a5c4fa8eab61f8a888e0c6937d63b537b0
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_Variable.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "Variable"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_V.pbtxt b/tensorflow/core/api_def/python_api/api_def_VariableV2.pbtxt
similarity index 50%
rename from tensorflow/core/api_def/python_api/api_def_V.pbtxt
rename to tensorflow/core/api_def/python_api/api_def_VariableV2.pbtxt
index 18be21a8866580e0a156c5edd034685062baa550..7f63a5775573432028db5eb0ffe5a7df7941bbb6 100644
--- a/tensorflow/core/api_def/python_api/api_def_V.pbtxt
+++ b/tensorflow/core/api_def/python_api/api_def_VariableV2.pbtxt
@@ -1,7 +1,3 @@
-op {
-  graph_op_name: "Variable"
-  visibility: HIDDEN
-}
 op {
   graph_op_name: "VariableV2"
   visibility: HIDDEN
diff --git a/tensorflow/core/api_def/python_api/api_def_WholeFileReader.pbtxt b/tensorflow/core/api_def/python_api/api_def_WholeFileReader.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..d1cc7a00281ee10f6d3a1a16e14d99e2952506f3
--- /dev/null
+++ b/tensorflow/core/api_def/python_api/api_def_WholeFileReader.pbtxt
@@ -0,0 +1,4 @@
+op {
+  graph_op_name: "WholeFileReader"
+  visibility: HIDDEN
+}
diff --git a/tensorflow/core/api_def/python_api/api_def_W.pbtxt b/tensorflow/core/api_def/python_api/api_def_WholeFileReaderV2.pbtxt
similarity index 50%
rename from tensorflow/core/api_def/python_api/api_def_W.pbtxt
rename to tensorflow/core/api_def/python_api/api_def_WholeFileReaderV2.pbtxt
index cd8861a98f6e58cd382c56ebc9669cfe34af8688..48e7b1e0eca37e116e657d0f5b8b9a1ba4b7f6e8 100644
--- a/tensorflow/core/api_def/python_api/api_def_W.pbtxt
+++ b/tensorflow/core/api_def/python_api/api_def_WholeFileReaderV2.pbtxt
@@ -1,7 +1,3 @@
-op {
-  graph_op_name: "WholeFileReader"
-  visibility: HIDDEN
-}
 op {
   graph_op_name: "WholeFileReaderV2"
   visibility: HIDDEN
diff --git a/tensorflow/core/api_def/python_api/api_def_Z.pbtxt b/tensorflow/core/api_def/python_api/api_def_ZerosLike.pbtxt
similarity index 100%
rename from tensorflow/core/api_def/python_api/api_def_Z.pbtxt
rename to tensorflow/core/api_def/python_api/api_def_ZerosLike.pbtxt
diff --git a/tensorflow/core/common_runtime/gpu/gpu_device.cc b/tensorflow/core/common_runtime/gpu/gpu_device.cc
index 12d44cc6b7d0b724b5fe1c427b31e455eeca07fe..fce8bc61f4135b9d62c35b6ec53fe1cd7acd32c1 100644
--- a/tensorflow/core/common_runtime/gpu/gpu_device.cc
+++ b/tensorflow/core/common_runtime/gpu/gpu_device.cc
@@ -1,4 +1,4 @@
-/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -652,6 +652,36 @@ Status BaseGPUDeviceFactory::CreateDevices(const SessionOptions& options,
   if (static_cast<size_t>(n) > valid_gpu_ids.size()) {
     n = valid_gpu_ids.size();
   }
+  if (!valid_gpu_ids.empty()) {
+    // Save the original device.
+    int original_device = 0;
+    cudaError_t err = cudaGetDevice(&original_device);
+    if (err != cudaSuccess) {
+      return errors::Internal("cudaGetDevice() failed. Status: ",
+                              cudaGetErrorString(err));
+    }
+    // Force to implicitly initialize CUDA runtime on each valid GPU before
+    // CreateGPUDevice().
+    for (int gpu_id : valid_gpu_ids) {
+      err = cudaSetDevice(gpu_id);
+      if (err != cudaSuccess) {
+        return errors::Internal("cudaSetDevice() on GPU:", gpu_id,
+                                " failed. Status: ", cudaGetErrorString(err));
+      }
+      err = cudaFree(nullptr);
+      if (err != cudaSuccess) {
+        return errors::Internal(
+            "CUDA runtime implicit initialization on GPU:", gpu_id,
+            " failed. Status: ", cudaGetErrorString(err));
+      }
+    }
+    // Reset to the original device.
+    err = cudaSetDevice(original_device);
+    if (err != cudaSuccess) {
+      return errors::Internal("cudaSetDevice() on GPU:", original_device,
+                              " failed. Status: ", cudaGetErrorString(err));
+    }
+  }
   for (int i = 0; i < n; i++) {
     BaseGPUDevice* gpu_device;
     TF_RETURN_IF_ERROR(CreateGPUDevice(
diff --git a/tensorflow/core/framework/common_shape_fns.cc b/tensorflow/core/framework/common_shape_fns.cc
index 315c99d32bf855d5f0941f0e5c76bb0548208257..ea66863bed3f3c9d91587a64370f635766d0794d 100644
--- a/tensorflow/core/framework/common_shape_fns.cc
+++ b/tensorflow/core/framework/common_shape_fns.cc
@@ -1232,6 +1232,8 @@ Status BroadcastBinaryOpShapeFn(InferenceContext* c) {
         dims.push_back(dim_y);
       } else if (c->Value(dim_y) == 1) {
         dims.push_back(dim_x);
+      } else if (dim_y.SameHandle(dim_x)) {
+        dims.push_back(dim_x);
       } else {
         dims.push_back(c->UnknownDim());
       }
diff --git a/tensorflow/core/framework/shape_inference.cc b/tensorflow/core/framework/shape_inference.cc
index ffa235d15c09a2a621558c6941aac7485e4bf737..5d6bf559bb30fdb2ceaa31ed232eddc01a67ce0b 100644
--- a/tensorflow/core/framework/shape_inference.cc
+++ b/tensorflow/core/framework/shape_inference.cc
@@ -418,11 +418,16 @@ void InferenceContext::Relax(DimensionHandle d0, DimensionHandle d1,
 
 Status InferenceContext::Merge(DimensionHandle d0, DimensionHandle d1,
                                DimensionHandle* out) {
-  if (d0.SameHandle(d1) || !ValueKnown(d1)) {
+  if (d0.SameHandle(d1)) {
+    *out = d0;
+    return Status::OK();
+  } else if (!ValueKnown(d1)) {
     *out = d0;
+    merged_dims_.emplace_back(d0, d1);
     return Status::OK();
   } else if (!ValueKnown(d0)) {
     *out = d1;
+    merged_dims_.emplace_back(d0, d1);
     return Status::OK();
   } else if (Value(d0) == Value(d1)) {
     *out = d0;
@@ -502,11 +507,16 @@ void InferenceContext::Relax(ShapeHandle s0, ShapeHandle s1, ShapeHandle* out) {
 
 Status InferenceContext::Merge(ShapeHandle s0, ShapeHandle s1,
                                ShapeHandle* out) {
-  if (s0.SameHandle(s1) || !RankKnown(s1)) {
+  if (s0.SameHandle(s1)) {
+    *out = s0;
+    return Status::OK();
+  } else if (!RankKnown(s1)) {
     *out = s0;
+    merged_shapes_.emplace_back(s0, s1);
     return Status::OK();
   } else if (!RankKnown(s0)) {
     *out = s1;
+    merged_shapes_.emplace_back(s0, s1);
     return Status::OK();
   }
 
@@ -539,6 +549,9 @@ Status InferenceContext::Merge(ShapeHandle s0, ShapeHandle s1,
                                      Value(d0), " and ", Value(d1));
     }
   }
+
+  merged_shapes_.emplace_back(s0, s1);
+
   if (return_s0 || return_s1) {
     *out = return_s0 ? s0 : s1;
     return Status::OK();
@@ -550,7 +563,14 @@ Status InferenceContext::Merge(ShapeHandle s0, ShapeHandle s1,
     // Invariant for merge was checked earlier, so CHECK is ok.
     TF_CHECK_OK(Merge(Dim(s0, i), Dim(s1, i), &dims[i]));
   }
-  return ReturnCreatedShape(dims, out);
+
+  Status s = ReturnCreatedShape(dims, out);
+  if (s.ok()) {
+    // Merge the new shape with s0. Since s0 and s1 are merged, this implies
+    // that s1 and out are also merged.
+    merged_shapes_.emplace_back(s0, *out);
+  }
+  return s;
 }
 
 Status InferenceContext::Subshape(ShapeHandle s, int64 start,
diff --git a/tensorflow/core/framework/shape_inference.h b/tensorflow/core/framework/shape_inference.h
index d1b610d68257cd037d1d0bdde2d9364237ae54d8..485980e42ee7cf4e16dcd6845a3adc22c41d2562 100644
--- a/tensorflow/core/framework/shape_inference.h
+++ b/tensorflow/core/framework/shape_inference.h
@@ -31,6 +31,7 @@ class ShapeRefinerTest;
 
 namespace grappler {
 class GraphProperties;
+class SymbolicShapeManager;
 }
 
 namespace shape_inference {
@@ -55,13 +56,14 @@ class Dimension {
 class DimensionHandle {
  public:
   DimensionHandle() {}
+  bool SameHandle(DimensionHandle d) const { return ptr_ == d.ptr_; }
+  std::size_t Handle() const { return reinterpret_cast<std::size_t>(ptr_); }
 
  private:
   DimensionHandle(const Dimension* dim) { ptr_ = dim; }
 
   const Dimension* operator->() { return ptr_; }
   bool IsSet() const { return ptr_ != nullptr; }
-  bool SameHandle(DimensionHandle d) const { return ptr_ == d.ptr_; }
 
   const Dimension* ptr_ = nullptr;
 
@@ -71,6 +73,8 @@ class DimensionHandle {
   friend class ShapeInferenceTestutil;
   friend class ::tensorflow::ShapeRefinerTest;
   friend class ShapeManager;
+  friend class ::tensorflow::grappler::GraphProperties;
+  friend class ::tensorflow::grappler::SymbolicShapeManager;
 
   // Intentionally copyable.
 };
@@ -87,6 +91,7 @@ class Shape {
 
   friend class InferenceContext;
   friend class ShapeManager;
+  friend class ::tensorflow::grappler::SymbolicShapeManager;
 
   TF_DISALLOW_COPY_AND_ASSIGN(Shape);
 };
@@ -94,12 +99,13 @@ class Shape {
 class ShapeHandle {
  public:
   ShapeHandle() {}
+  bool SameHandle(ShapeHandle s) const { return ptr_ == s.ptr_; }
+  std::size_t Handle() const { return reinterpret_cast<std::size_t>(ptr_); }
 
  private:
   ShapeHandle(const Shape* shape) { ptr_ = shape; }
   const Shape* operator->() { return ptr_; }
   bool IsSet() const { return ptr_ != nullptr; }
-  bool SameHandle(ShapeHandle s) const { return ptr_ == s.ptr_; }
 
   const Shape* ptr_ = nullptr;
 
@@ -108,6 +114,7 @@ class ShapeHandle {
   friend class ShapeInferenceTestutil;
   friend class ::tensorflow::ShapeRefinerTest;
   friend class ShapeManager;
+  friend class ::tensorflow::grappler::SymbolicShapeManager;
 
   // Intentionally copyable.
 };
@@ -334,22 +341,28 @@ class InferenceContext {
     if (s->rank_ == kUnknownRank) {
       return UnknownDim();
     }
+    return DimKnownRank(s, idx);
+  }
+  // As above, but asserts that the rank of the shape is known.
+  static DimensionHandle DimKnownRank(ShapeHandle s, int64 idx) {
+    CHECK_NE(s->rank_, kUnknownRank);
     if (idx < 0) {
       return s->dims_[s->dims_.size() + idx];
     }
     return s->dims_[idx];
   }
-  int32 Rank(ShapeHandle s) const {
+
+  static int32 Rank(ShapeHandle s) {
     DCHECK(s.IsSet());
     return s.IsSet() ? s->rank_ : kUnknownRank;
   }
-  bool RankKnown(ShapeHandle s) const {
+  static bool RankKnown(ShapeHandle s) {
     return (s.IsSet() && (Rank(s) != kUnknownRank));
   }
-  inline int64 Value(DimensionOrConstant d) const {
+  static inline int64 Value(DimensionOrConstant d) {
     return d.dim.IsSet() ? d.dim->value_ : d.val;
   }
-  inline bool ValueKnown(DimensionOrConstant d) const {
+  static inline bool ValueKnown(DimensionOrConstant d) {
     return Value(d) != kUnknownDim;
   }
 
@@ -601,6 +614,14 @@ class InferenceContext {
 
   int graph_def_version() const { return graph_def_version_; }
 
+  const std::vector<std::pair<ShapeHandle, ShapeHandle>>& MergedShapes() const {
+    return merged_shapes_;
+  }
+  const std::vector<std::pair<DimensionHandle, DimensionHandle>>& MergedDims()
+      const {
+    return merged_dims_;
+  }
+
  private:
   // Creates and stores shapes for use in InferenceContext.
   class ShapeManager {
@@ -717,6 +738,13 @@ class InferenceContext {
   // constructor is removed.
   Status construction_status_;
 
+  // Pair of shape or dim handles that are equivalent, ie that represent the
+  // same underlying shape of dimension. Note that for each pair at least one of
+  // the handles must contain an unknown shape, since we don't keep track of
+  // known shapes or dims here.
+  std::vector<std::pair<ShapeHandle, ShapeHandle>> merged_shapes_;
+  std::vector<std::pair<DimensionHandle, DimensionHandle>> merged_dims_;
+
   TF_DISALLOW_COPY_AND_ASSIGN(InferenceContext);
 };
 
diff --git a/tensorflow/core/framework/shape_inference_test.cc b/tensorflow/core/framework/shape_inference_test.cc
index d36ff5822bae15bf0eb44c5f657afe3de09a1020..d03cc8ce6dd5f1f70270c05dfaf11f8271a6e45b 100644
--- a/tensorflow/core/framework/shape_inference_test.cc
+++ b/tensorflow/core/framework/shape_inference_test.cc
@@ -485,18 +485,33 @@ TEST_F(ShapeInferenceTest, MergeDim) {
   EXPECT_TRUE(c.Merge(d_unknown, d_unknown_b, &out).ok());
   EXPECT_TRUE(SameHandle(d_unknown, out));
 
-  // Merging with self returns self.
+  auto merged_dims = c.MergedDims();
+  ASSERT_EQ(3, merged_dims.size());
+  EXPECT_TRUE(merged_dims[0].first.SameHandle(d2));
+  EXPECT_TRUE(merged_dims[0].second.SameHandle(d_unknown));
+  EXPECT_TRUE(merged_dims[1].first.SameHandle(d_unknown));
+  EXPECT_TRUE(merged_dims[1].second.SameHandle(d2));
+  EXPECT_TRUE(merged_dims[2].first.SameHandle(d_unknown));
+  EXPECT_TRUE(merged_dims[2].second.SameHandle(d_unknown_b));
+
+  // Merging with self is a no-op and returns self.
   EXPECT_TRUE(c.Merge(d2, d2, &out).ok());
   EXPECT_TRUE(SameHandle(d2, out));
   EXPECT_TRUE(c.Merge(d_unknown, d_unknown, &out).ok());
   EXPECT_TRUE(SameHandle(d_unknown, out));
 
-  // Merging equal values returns first one.
+  merged_dims = c.MergedDims();
+  EXPECT_EQ(3, merged_dims.size());
+
+  // Merging equal values is a no op and returns first one.
   EXPECT_TRUE(c.Merge(d2, d2_b, &out).ok());
   EXPECT_TRUE(SameHandle(d2, out));
   EXPECT_TRUE(c.Merge(d2_b, d2, &out).ok());
   EXPECT_TRUE(SameHandle(d2_b, out));
 
+  merged_dims = c.MergedDims();
+  EXPECT_EQ(3, merged_dims.size());
+
   // Merging unequal values is an error.
   EXPECT_TRUE(
       StringPiece(c.Merge(d2, d1, &out).ToString())
@@ -510,6 +525,9 @@ TEST_F(ShapeInferenceTest, MergeDim) {
               "Invalid argument: Dimensions must be equal, but are 1 and 2"));
 
   EXPECT_FALSE(IsSet(out));
+
+  merged_dims = c.MergedDims();
+  EXPECT_EQ(3, merged_dims.size());
 }
 
 TEST_F(ShapeInferenceTest, RelaxDim) {
@@ -652,10 +670,22 @@ TEST_F(ShapeInferenceTest, MergeShape) {
   EXPECT_TRUE(c.Merge(s_unknown, s_unknown_b, &out).ok());
   EXPECT_TRUE(SameHandle(s_unknown, out));
 
+  auto merged_shapes = c.MergedShapes();
+  ASSERT_EQ(3, merged_shapes.size());
+  EXPECT_TRUE(merged_shapes[0].first.SameHandle(s_unknown));
+  EXPECT_TRUE(merged_shapes[0].second.SameHandle(s_1_2));
+  EXPECT_TRUE(merged_shapes[1].first.SameHandle(s_u_2));
+  EXPECT_TRUE(merged_shapes[1].second.SameHandle(s_unknown));
+  EXPECT_TRUE(merged_shapes[2].first.SameHandle(s_unknown));
+  EXPECT_TRUE(merged_shapes[2].second.SameHandle(s_unknown_b));
+
   // Merging with self returns self.
   EXPECT_TRUE(c.Merge(s_1_2, s_1_2, &out).ok());
   EXPECT_TRUE(SameHandle(out, s_1_2));
 
+  merged_shapes = c.MergedShapes();
+  EXPECT_EQ(3, merged_shapes.size());
+
   // Merging where one of the inputs is the right answer - return that input.
   out = ShapeHandle();
   EXPECT_TRUE(c.Merge(s_1_2, s_u_2, &out).ok());
@@ -664,6 +694,13 @@ TEST_F(ShapeInferenceTest, MergeShape) {
   EXPECT_TRUE(c.Merge(s_u_2, s_1_2, &out).ok());
   EXPECT_TRUE(SameHandle(s_1_2, out));
 
+  merged_shapes = c.MergedShapes();
+  ASSERT_EQ(5, merged_shapes.size());
+  EXPECT_TRUE(merged_shapes[3].first.SameHandle(s_1_2));
+  EXPECT_TRUE(merged_shapes[3].second.SameHandle(s_u_2));
+  EXPECT_TRUE(merged_shapes[4].first.SameHandle(s_u_2));
+  EXPECT_TRUE(merged_shapes[4].second.SameHandle(s_1_2));
+
   // Merging where neither input is the right answer.
   EXPECT_TRUE(c.Merge(s_u_2, s_1_u, &out).ok());
   EXPECT_FALSE(SameHandle(out, s_u_2));
@@ -672,11 +709,23 @@ TEST_F(ShapeInferenceTest, MergeShape) {
   EXPECT_TRUE(SameHandle(c.Dim(s_1_u, 0), c.Dim(out, 0)));
   EXPECT_TRUE(SameHandle(c.Dim(s_u_2, 1), c.Dim(out, 1)));
 
+  merged_shapes = c.MergedShapes();
+  ASSERT_EQ(7, merged_shapes.size());
+  EXPECT_TRUE(merged_shapes[5].first.SameHandle(s_u_2));
+  EXPECT_TRUE(merged_shapes[5].second.SameHandle(s_1_u));
+  EXPECT_TRUE(merged_shapes[6].first.SameHandle(s_u_2));
+  EXPECT_TRUE(merged_shapes[6].second.SameHandle(out));
+
   auto s_u1 = c.UnknownShapeOfRank(1);
   auto s_u2 = c.UnknownShapeOfRank(1);
   TF_EXPECT_OK(c.Merge(s_u1, s_u2, &out));
   EXPECT_TRUE(SameHandle(s_u1, out));
 
+  merged_shapes = c.MergedShapes();
+  ASSERT_EQ(8, merged_shapes.size());
+  EXPECT_TRUE(merged_shapes[7].first.SameHandle(s_u1));
+  EXPECT_TRUE(merged_shapes[7].second.SameHandle(s_u2));
+
   // Incompatible merges give errors and set out to nullptr.
   out = s_unknown;
   EXPECT_TRUE(
@@ -701,6 +750,9 @@ TEST_F(ShapeInferenceTest, MergeShape) {
               "Invalid argument: Shapes must be equal rank, but are 1 and 2"));
 
   EXPECT_FALSE(IsSet(out));
+
+  merged_shapes = c.MergedShapes();
+  EXPECT_EQ(8, merged_shapes.size());
 }
 
 TEST_F(ShapeInferenceTest, MergePrefix) {
diff --git a/tensorflow/core/graph/graph_constructor.cc b/tensorflow/core/graph/graph_constructor.cc
index 8fe4f535fbb8c1a93fd06c5858ad2095d50f6808..753cb260e51185e66f74e1545f3732b0731e03f0 100644
--- a/tensorflow/core/graph/graph_constructor.cc
+++ b/tensorflow/core/graph/graph_constructor.cc
@@ -75,6 +75,7 @@ class GraphConstructor {
           prefix(in.prefix.empty() || StringPiece(in.prefix).ends_with("/")
                      ? in.prefix
                      : in.prefix + "/"),
+          uniquify_names(in.uniquify_names),
           input_map(in.input_map),
           skip_mapped_nodes(in.skip_mapped_nodes),
           control_dependencies(in.control_dependencies),
@@ -86,6 +87,7 @@ class GraphConstructor {
     bool expect_device_spec;
 
     string prefix;
+    bool uniquify_names;
     std::map<TensorId, TensorId> input_map;
     bool skip_mapped_nodes;
     std::vector<string> control_dependencies;
@@ -190,6 +192,20 @@ class GraphConstructor {
   void AddPrefixToNodeDef(const std::vector<bool>& input_already_exists,
                           NodeDef* node_def);
 
+  // Modifies `node_def` if its name isn't unique, or if any of its inputs'
+  // names have been uniquified. This must be called in topological order on all
+  // nodes.
+  void UniquifyNames(const std::vector<bool>& input_already_exists,
+                     NodeDef* node_def);
+
+  // Returns true if `name` already exists in `g_` (either as a node name or
+  // prefix).
+  bool NameExists(StringPiece name);
+
+  // Returns a unique version of `original_name`, or `original_name` if it's
+  // already unique in the graph.
+  string FindUniqueName(StringPiece original_name);
+
   // From constructor
   const Options opts_;
   const NodeDefSlice node_defs_;
@@ -224,9 +240,16 @@ class GraphConstructor {
   // alternative implementation of std::unordered_map.
   std::unordered_map<StringPiece, NodeInfo, StringPiece::Hasher> gdef_nodes_;
 
-  // Mapping from node name to the existing node in g_
+  // Mapping from node name to the existing node in g_.
   std::unordered_map<StringPiece, Node*, StringPiece::Hasher> existing_nodes_;
 
+  // Prefixes already used in the graph.
+  std::unordered_set<StringPiece, StringPiece::Hasher> existing_prefixes_;
+
+  // Imported node names that have been uniquified. The key is the original
+  // name, the value is the new unique name.
+  std::unordered_map<string, string> uniquified_names_;
+
   // Index of NodeDefs in node_defs_ with all inputs already converted.
   std::vector<int> ready_;
 
@@ -281,6 +304,7 @@ bool NodeNameInValues(const std::vector<string>& control_dependencies,
 
 Status GraphConstructor::EnsureNoNameCollisions() {
   existing_nodes_.reserve(g_->num_nodes());
+  // Populate existing_nodes_ and existing_prefixes_.
   for (Node* n : g_->nodes()) {
     bool already_exists = !existing_nodes_.insert({n->name(), n}).second;
     if (already_exists) {
@@ -296,18 +320,22 @@ Status GraphConstructor::EnsureNoNameCollisions() {
             n->name(), "'");
       }
     }
+    // Add all of node's prefixes to existing_prefixes_ (if it has any).
+    size_t idx = -1;
+    while ((idx = n->name().find('/', idx + 1)) != string::npos) {
+      StringPiece name(n->name());
+      existing_prefixes_.insert(name.substr(0, idx));
+    }
   }
-  if (opts_.prefix.empty() && opts_.importing) {
+  if (opts_.prefix.empty() && opts_.importing && !opts_.uniquify_names) {
     for (const NodeDef* n : node_defs_) {
       const string& name = n->name();
-      if (existing_nodes_.find(name) != existing_nodes_.end()) {
-        return errors::InvalidArgument("Node '", name,
+      if (NameExists(name)) {
+        return errors::InvalidArgument("Node name '", name,
                                        "' already exists in the Graph");
       }
     }
   } else if (!opts_.prefix.empty()) {
-    // Importing nodes with a prefix. No nodes should exist with the same
-    // prefix.
     StringPiece prefix_no_slash(opts_.prefix);
     prefix_no_slash.remove_suffix(1);
     if (!IsValidNodeName(prefix_no_slash, false)) {
@@ -315,13 +343,11 @@ Status GraphConstructor::EnsureNoNameCollisions() {
                                      opts_.prefix,
                                      "' would lead to invalid node names");
     }
-    for (const Node* n : g_->nodes()) {
-      if (StringPiece(n->name()).starts_with(opts_.prefix)) {
-        return errors::InvalidArgument(
-            "Import node name prefix conflicts with names of nodes already in "
-            "the Graph, such as '",
-            n->name(), "'");
-      }
+    if (NameExists(prefix_no_slash)) {
+      return errors::InvalidArgument("Import node name prefix '",
+                                     prefix_no_slash,
+                                     "' conflicts with "
+                                     "name already used in the graph");
     }
   }
   return Status::OK();
@@ -663,19 +689,18 @@ void GraphConstructor::AddControlDependencies(
 
 void GraphConstructor::AddPrefixToNodeDef(
     const std::vector<bool>& input_already_exists, NodeDef* node_def) {
-  const string& prefix = opts_.prefix;
-  if (prefix.empty()) return;
-  node_def->set_name(strings::StrCat(prefix, node_def->name()));
+  if (opts_.prefix.empty()) return;
+  node_def->set_name(strings::StrCat(opts_.prefix, node_def->name()));
   // Update names of input nodes
   for (int i = 0; i < node_def->input_size(); ++i) {
     StringPiece input(node_def->input(i));
     // Skip remapped inputs (which already exist in g_ and are not being
-    // imported)
+    // imported).
     if (input_already_exists[i]) continue;
     if (input.Consume("^")) {
-      node_def->set_input(i, strings::StrCat("^", prefix, input));
+      node_def->set_input(i, strings::StrCat("^", opts_.prefix, input));
     } else {
-      node_def->set_input(i, strings::StrCat(prefix, input));
+      node_def->set_input(i, strings::StrCat(opts_.prefix, input));
     }
   }
   // Update names of colocation groups
@@ -685,12 +710,62 @@ void GraphConstructor::AddPrefixToNodeDef(
     for (int i = 0; i < list->s_size(); ++i) {
       StringPiece v(list->s(i));
       if (v.Consume(kColocationGroupPrefix)) {
-        list->set_s(i, strings::StrCat(kColocationGroupPrefix, prefix, v));
+        list->set_s(i,
+                    strings::StrCat(kColocationGroupPrefix, opts_.prefix, v));
       }
     }
   }
 }
 
+void GraphConstructor::UniquifyNames(
+    const std::vector<bool>& input_already_exists, NodeDef* node_def) {
+  if (NameExists(node_def->name())) {
+    string old_name = node_def->name();
+    node_def->set_name(FindUniqueName(node_def->name()));
+    uniquified_names_[old_name] = node_def->name();
+  }
+  for (int i = 0; i < node_def->input_size(); ++i) {
+    // Skip remapped inputs (which already exist in g_ and are not being
+    // imported).
+    if (input_already_exists[i]) continue;
+    TensorId id = ParseTensorName(node_def->input(i));
+    // We require that UniquifyNames() is called on all NodeDefs in topological
+    // order. This guarantees that node_def's inputs will already be uniquified
+    // if necessary.
+    auto iter = uniquified_names_.find(id.first.ToString());
+    if (iter == uniquified_names_.end()) continue;
+    id.first = iter->second;
+    node_def->set_input(i, id.ToString());
+  }
+  // Update names of colocation groups
+  if (node_def->attr().find(kColocationAttrName) != node_def->attr().end()) {
+    auto* list =
+        node_def->mutable_attr()->at(kColocationAttrName).mutable_list();
+    for (int i = 0; i < list->s_size(); ++i) {
+      StringPiece v(list->s(i));
+      if (v.Consume(kColocationGroupPrefix)) {
+        auto iter = uniquified_names_.find(v.ToString());
+        if (iter == uniquified_names_.end()) continue;
+        list->set_s(i, strings::StrCat(kColocationGroupPrefix, iter->second));
+      }
+    }
+  }
+}
+
+bool GraphConstructor::NameExists(StringPiece name) {
+  if (existing_nodes_.find(name) != existing_nodes_.end()) return true;
+  return existing_prefixes_.find(name) != existing_prefixes_.end();
+}
+
+string GraphConstructor::FindUniqueName(StringPiece original_name) {
+  string name = original_name.ToString();
+  int count = 1;
+  while (NameExists(name)) {
+    name = strings::StrCat(original_name, "_", count++);
+  }
+  return name;
+}
+
 Status GraphConstructor::IsNodeFullyMapped(const NodeDef& node_def,
                                            bool* is_node_mapped) {
   const OpDef* op_def;
@@ -825,7 +900,11 @@ Status GraphConstructor::Convert() {
 
     Node* node;
     if (opts_.importing) {
-      AddPrefixToNodeDef(input_already_exists, &imported_node_def);
+      if (!opts_.prefix.empty()) {
+        AddPrefixToNodeDef(input_already_exists, &imported_node_def);
+      } else if (opts_.uniquify_names) {
+        UniquifyNames(input_already_exists, &imported_node_def);
+      }
       TF_RETURN_IF_ERROR(ModifyNodeDefForImport(&imported_node_def));
     }
     TF_RETURN_IF_ERROR(MakeNode(*node_def, &node));
diff --git a/tensorflow/core/graph/graph_constructor.h b/tensorflow/core/graph/graph_constructor.h
index a3644788788544728193e4f648fa562e1275ffdc..416c0ee9ae8f5539a5367773e1cf5128d6db327a 100644
--- a/tensorflow/core/graph/graph_constructor.h
+++ b/tensorflow/core/graph/graph_constructor.h
@@ -54,13 +54,20 @@ extern Status ConvertNodeDefsToGraph(const GraphConstructorOptions& opts,
 
 // Options for calling ImportGraphDef().
 struct ImportGraphDefOptions {
-  ImportGraphDefOptions() : skip_mapped_nodes(false) {}
+  ImportGraphDefOptions() : uniquify_names(false), skip_mapped_nodes(false) {}
 
   // Name prefix to use for nodes imported from the GraphDef.  For example, if
   // prefix="animals" and GraphDef contains a node "bunny" then the node will be
-  // named "animals/bunny" in *g.
+  // named "animals/bunny" in *g. Must not be already used as a node name or
+  // prefix in the graph.
   string prefix;
 
+  // If true, imported node names will be modified if their name already exists
+  // in the graph. If false, conflicting names will be treated as an error. Note
+  // that this option has no effect if `prefix` is specified, since `prefix`
+  // will guarantee all node names are unique.
+  bool uniquify_names;
+
   // Maps tensors in `gdef` to existing tensors in `g`. Inputs in `gdef`
   // corresponding to `input_map` keys will be remapped to the nodes in `g`
   // corresponding to the values.
diff --git a/tensorflow/core/graph/graph_constructor_test.cc b/tensorflow/core/graph/graph_constructor_test.cc
index 5242c56ce6de63fbe1d03e596cc6123844be4a50..cd541c7d86f2e7d26d844e6772ff3b5948de27ef 100644
--- a/tensorflow/core/graph/graph_constructor_test.cc
+++ b/tensorflow/core/graph/graph_constructor_test.cc
@@ -1731,6 +1731,136 @@ TEST_F(GraphConstructorTest, ImportGraphDef_ReturnNodesErrors) {
                "currently supported"});
 }
 
+TEST_F(GraphConstructorTest, ImportGraphDef_UniquifyNames) {
+  ShapeRefiner refiner(TF_GRAPH_DEF_VERSION, graph_.op_registry());
+
+  const char* graph_def_str =
+      "node { name: 'A' op: 'TestInput' }"
+      "node { name: 'B' op: 'TestOneInputTwoOutputs' input: ['A'] }";
+
+  // Initial import
+  ImportGraphDefOptions opts;
+  opts.uniquify_names = true;
+  opts.return_nodes.push_back("A");
+  opts.return_nodes.push_back("B");
+  ImportGraphDefResults results;
+  ExpectOK(graph_def_str, opts, &refiner, &results);
+
+  ASSERT_EQ(results.return_nodes.size(), 2);
+  EXPECT_EQ(results.return_nodes[0]->name(), "A");
+  EXPECT_EQ(results.return_nodes[1]->name(), "B");
+  EXPECT_EQ(results.return_nodes[1]->def().input(0), "A");
+
+  // Repeat the same import
+  results = ImportGraphDefResults();
+  ExpectOK(graph_def_str, opts, &refiner, &results);
+
+  ASSERT_EQ(results.return_nodes.size(), 2);
+  EXPECT_EQ(results.return_nodes[0]->name(), "A_1");
+  EXPECT_EQ(results.return_nodes[1]->name(), "B_1");
+  EXPECT_EQ(results.return_nodes[1]->def().input(0), "A_1:0");
+
+  // Repeat the same import again
+  results = ImportGraphDefResults();
+  ExpectOK(graph_def_str, opts, &refiner, &results);
+
+  ASSERT_EQ(results.return_nodes.size(), 2);
+  EXPECT_EQ(results.return_nodes[0]->name(), "A_2");
+  EXPECT_EQ(results.return_nodes[1]->name(), "B_2");
+  EXPECT_EQ(results.return_nodes[1]->def().input(0), "A_2:0");
+
+  // Import with existing de-duped node names
+  opts = ImportGraphDefOptions();
+  opts.uniquify_names = true;
+  opts.return_nodes.push_back("A_1");
+  opts.return_nodes.push_back("B_1");
+  results = ImportGraphDefResults();
+  ExpectOK(
+      "node { name: 'A_1' op: 'TestInput' }"
+      "node { name: 'B_1' op: 'TestOneInputTwoOutputs' input: ['A_1:0'] }",
+      opts, &refiner, &results);
+
+  ASSERT_EQ(results.return_nodes.size(), 2);
+  EXPECT_EQ(results.return_nodes[0]->name(), "A_1_1");
+  EXPECT_EQ(results.return_nodes[1]->name(), "B_1_1");
+  EXPECT_EQ(results.return_nodes[1]->def().input(0), "A_1_1:0");
+
+  // Create node with prefix and then import node with same name
+  ExpectOK("node { name: 'foo/abc' op: 'ABC' }");
+  opts = ImportGraphDefOptions();
+  opts.uniquify_names = true;
+  opts.return_nodes.push_back("foo");
+  results = ImportGraphDefResults();
+  ExpectOK("node { name: 'foo' op: 'TestInput' }", opts, &refiner, &results);
+
+  ASSERT_EQ(results.return_nodes.size(), 1);
+  EXPECT_EQ(results.return_nodes[0]->name(), "foo_1");
+
+  // Imported nodes can't conflict with intermediate name (but can conflict with
+  // outer name)
+  ExpectOK("node { name: 'outer/inner/abc' op: 'ABC' }");
+
+  opts = ImportGraphDefOptions();
+  opts.uniquify_names = true;
+  opts.return_nodes.push_back("outer");
+  opts.return_nodes.push_back("inner");
+  opts.return_nodes.push_back("abc");
+  opts.return_nodes.push_back("outer/inner");
+  opts.return_nodes.push_back("outer/inner/abc");
+  results = ImportGraphDefResults();
+  ExpectOK(
+      "node { name: 'outer' op: 'TestInput' }"
+      "node { name: 'inner' op: 'TestInput' }"
+      "node { name: 'abc' op: 'TestInput' }"
+      "node { name: 'outer/inner' op: 'TestInput' }"
+      "node { name: 'outer/inner/abc' op: 'TestInput' }",
+      opts, &refiner, &results);
+
+  ASSERT_EQ(results.return_nodes.size(), 5);
+  EXPECT_EQ(results.return_nodes[0]->name(), "outer_1");
+  EXPECT_EQ(results.return_nodes[1]->name(), "inner");
+  EXPECT_EQ(results.return_nodes[2]->name(), "abc");
+  EXPECT_EQ(results.return_nodes[3]->name(), "outer/inner_1");
+  EXPECT_EQ(results.return_nodes[4]->name(), "outer/inner/abc_1");
+
+  // Import with input map containing conflicting names
+  opts = ImportGraphDefOptions();
+  opts.uniquify_names = true;
+  opts.input_map[TensorId("A", 0)] = TensorId("A", 0);
+  opts.input_map[TensorId("B", 0)] = TensorId("B", 0);
+  opts.return_nodes.push_back("A");
+  opts.return_nodes.push_back("B");
+  results = ImportGraphDefResults();
+  ExpectOK(graph_def_str, opts, &refiner, &results);
+
+  ASSERT_EQ(results.return_nodes.size(), 2);
+  EXPECT_EQ(results.return_nodes[0]->name(), "A_3");
+  EXPECT_EQ(results.return_nodes[1]->name(), "B_3");
+  EXPECT_EQ(results.return_nodes[1]->def().input(0), "A:0");
+
+  // Check that colocation groups are updated
+  opts = ImportGraphDefOptions();
+  opts.uniquify_names = true;
+  opts.return_nodes.push_back("A");
+  opts.return_nodes.push_back("B");
+  results = ImportGraphDefResults();
+  ExpectOK(
+      "node { name: 'A' op: 'TestInput' }"
+      "node { name: 'B' op: 'TestOneInputTwoOutputs' input: ['A:0'] "
+      "       attr { key: '_class' value { list { s:'loc:@A' } } } }",
+      opts, &refiner, &results);
+
+  ASSERT_EQ(results.return_nodes.size(), 2);
+  EXPECT_EQ(results.return_nodes[0]->name(), "A_4");
+  EXPECT_EQ(results.return_nodes[1]->name(), "B_4");
+  EXPECT_EQ(results.return_nodes[1]->def().input(0), "A_4:0");
+  const AttrValue* class_attr =
+      results.return_nodes[1]->attrs().Find(kColocationAttrName);
+  ASSERT_TRUE(class_attr != nullptr);
+  ASSERT_EQ(class_attr->list().s_size(), 1);
+  EXPECT_EQ(class_attr->list().s(0), "loc:@A_4");
+}
+
 TEST_F(GraphConstructorTest, ImportGraphDef_WithCycle) {
   // Test graph produced in python using:
   /*
@@ -2157,7 +2287,7 @@ TEST_F(GraphConstructorTest, ImportGraphDef_ErrorsDoNoChangeTheGraph) {
   } while (0)
 
   EXPECT_IMPORT_FAILURE(def, opts,
-                        "Node 'scope/A' already exists in the Graph");
+                        "Node name 'scope/A' already exists in the Graph");
 
   GraphDef bad_def;
   ASSERT_TRUE(protobuf::TextFormat::ParseFromString(
@@ -2240,7 +2370,7 @@ TEST_F(GraphConstructorTest, ImportGraphDef_ErrorsDoNoChangeTheGraph) {
   ASSERT_TRUE(protobuf::TextFormat::ParseFromString(
       "node{name:'scope/A' op:'TestParams'}", &bad_def));
   EXPECT_IMPORT_FAILURE(bad_def, opts,
-                        "Node 'scope/A' already exists in the Graph");
+                        "Node name 'scope/A' already exists in the Graph");
 
   parsed = protobuf::TextFormat::ParseFromString(
       R"EOF(
diff --git a/tensorflow/core/grappler/costs/graph_properties.cc b/tensorflow/core/grappler/costs/graph_properties.cc
index e9cb2ee09d52d5438c80d4601623c47eaf973a8c..44322a2d8c6158431b238978bfeef779483a06b6 100644
--- a/tensorflow/core/grappler/costs/graph_properties.cc
+++ b/tensorflow/core/grappler/costs/graph_properties.cc
@@ -26,12 +26,205 @@ limitations under the License.
 namespace tensorflow {
 namespace grappler {
 
+using shape_inference::Dimension;
+using shape_inference::DimensionHandle;
 using shape_inference::InferenceContext;
+using shape_inference::Shape;
 using shape_inference::ShapeAndType;
 using shape_inference::ShapeHandle;
 
 namespace {
 
+template <typename Handle>
+struct HashHandle {
+  std::size_t operator()(const Handle& h) const { return h.Handle(); }
+};
+template <typename Handle>
+struct CompareHandle {
+  bool operator()(const Handle& h1, const Handle& h2) const {
+    return h1.SameHandle(h2);
+  }
+};
+
+template <typename Handle>
+struct HandleToObject {};
+template <>
+struct HandleToObject<ShapeHandle> {
+  typedef TensorShapeProto Object;
+
+  static TensorShapeProto Unknown() {
+    TensorShapeProto result;
+    result.set_unknown_rank(true);
+    return result;
+  }
+};
+
+template <>
+struct HandleToObject<DimensionHandle> {
+  typedef int64 Object;
+
+  static int64 Unknown() { return -1; }
+};
+
+template <typename Handle>
+struct Processor {
+  // Extract the shape or dim denoted by the handle.
+  void ExtractValue(Handle /*t1*/,
+                    typename HandleToObject<Handle>::Object* result) {}
+  // Merge the shapes or dims.
+  Status Merge(Handle /*t1*/, Handle /*t2*/,
+               typename HandleToObject<Handle>::Object* result) {
+    return Status::OK();
+  }
+};
+
+template <>
+struct Processor<DimensionHandle> {
+  // Assign a negative id to unknown dimensions, starting at -2 (the -1 id
+  // reserved by TensorFlow).
+  void ExtractValue(DimensionHandle d, int64* result) {
+    if (!InferenceContext::ValueKnown(d)) {
+      *result = -counter;
+      counter++;
+    } else {
+      CHECK_LE(0, InferenceContext::Value(d));
+      *result = InferenceContext::Value(d);
+    }
+  }
+
+  // Merge the dimensions d1 and d2. Return the known shape if there is one,
+  // otherwise look for a symbolic shape. If there is no symbolic shape and no
+  // known shape, the shape if fully unknown so return -1.
+  Status Merge(DimensionHandle d1, DimensionHandle d2, int64* result) {
+    const int64 dim1 = InferenceContext::Value(d1);
+    const int64 dim2 = InferenceContext::Value(d2);
+
+    if (dim1 >= 0 && dim2 >= 0) {
+      CHECK_EQ(dim1, dim2);
+      *result = dim1;
+    } else if (dim1 >= 0 && dim2 < 0) {
+      *result = dim1;
+    } else if (dim1 < 0 && dim2 >= 0) {
+      *result = dim2;
+    } else if (dim1 < -1) {
+      *result = dim1;
+    } else if (dim2 < -1) {
+      *result = dim2;
+    } else {
+      CHECK_EQ(dim1, dim2);
+      CHECK_EQ(-1, dim1);
+      *result = -1;
+    }
+    return Status::OK();
+  }
+
+ private:
+  int64 counter = 2;
+};
+
+// Traditional Disjoint-Set datastructure with path compression.
+// (https://en.wikipedia.org/wiki/Disjoint-set_data_structure)
+template <typename Handle>
+class DisjointSet {
+ public:
+  DisjointSet(const Processor<Handle>& processor) : processor_(processor) {}
+  ~DisjointSet() {
+    for (auto rep : nodes_) {
+      delete rep.second;
+    }
+  }
+
+  Status Merge(Handle x, Handle y);
+  const typename HandleToObject<Handle>::Object GetMergedValue(Handle value);
+
+ private:
+  // All the handles that belong to the same set are part of the same tree, and
+  // utimately represented by the root of that tree.
+  struct Rep {
+    // Parent in the tree used to encode the set.
+    Rep* parent;
+    // Rank in the tree, used to figure out how to compress the path to the root
+    // of the tree.
+    int rank;
+    // The handle.
+    typename HandleToObject<Handle>::Object value;
+  };
+
+  // Create a new set for the value if none exists, or return its representative
+  // node otherwise.
+  Rep* Find(Handle value);
+
+ private:
+  Processor<Handle> processor_;
+  std::unordered_map<Handle, Rep*, HashHandle<Handle>, CompareHandle<Handle>>
+      nodes_;
+};
+
+template <typename Handle>
+const typename HandleToObject<Handle>::Object
+DisjointSet<Handle>::GetMergedValue(Handle value) {
+  Rep* rep = Find(value);
+  if (!rep) {
+    // We don't know anything about this handle.
+    return HandleToObject<Handle>::Unknown();
+  }
+  return rep->value;
+}
+
+template <typename Handle>
+Status DisjointSet<Handle>::Merge(Handle x, Handle y) {
+  Rep* x_root = Find(x);
+  Rep* y_root = Find(y);
+
+  // x and y are already in the same set
+  if (x_root == y_root) {
+    return Status::OK();
+  }
+  // x and y are not in same set, so we merge them
+  // Use the occasion to strengthen what we know about the handle by merging the
+  // information about the 2 subsets.
+  if (x_root->rank < y_root->rank) {
+    TF_RETURN_IF_ERROR(processor_.Merge(y, x, &y_root->value));
+    x_root->parent = y_root;
+  } else if (x_root->rank > y_root->rank) {
+    TF_RETURN_IF_ERROR(processor_.Merge(x, y, &x_root->value));
+    y_root->parent = x_root;
+  } else {
+    TF_RETURN_IF_ERROR(processor_.Merge(x, y, &x_root->value));
+    // Arbitrarily make one root the new parent
+    y_root->parent = x_root;
+    x_root->rank = x_root->rank + 1;
+  }
+  return Status::OK();
+}
+
+template <typename Handle>
+typename DisjointSet<Handle>::Rep* DisjointSet<Handle>::Find(Handle value) {
+  auto it = nodes_.find(value);
+  if (it == nodes_.end()) {
+    // This is the first time we process this handle, create an entry for it.
+    Rep* node = new Rep;
+    node->parent = node;
+    node->rank = 0;
+    processor_.ExtractValue(value, &node->value);
+    nodes_[value] = node;
+    return node;
+  }
+  // Return the representative for the set, which is the root of the tree. Apply
+  // path compression to speedup future queries.
+  Rep* node = it->second;
+  Rep* root = node->parent;
+  while (root != root->parent) {
+    root = root->parent;
+  }
+  while (node->parent != root) {
+    Rep* next = node->parent;
+    node->parent = root;
+    node = next;
+  }
+  return root;
+}
+
 // If a Merge node has a NextIteration node as an input then that input will
 // try to forward an UnknownShape at graph construction time. However, the
 // Merge shape function will always propagate an UnknownShape if any of its
@@ -133,6 +326,58 @@ bool IsEnterWithQueue(const Node& node) {
 
 }  // namespace
 
+// Keep track of shapes and dimensions in a graph.
+// In particular, use disjoint sets to track equivalence between shapes and
+// dims, and consolidate the information globally.
+class SymbolicShapeManager {
+ public:
+  SymbolicShapeManager() : shapes_(shape_processor_), dims_(dim_processor_) {}
+
+  Status Merge(ShapeHandle s1, ShapeHandle s2) {
+    if (!s1.IsSet() || !s2.IsSet()) {
+      return Status::OK();
+    }
+    TF_RETURN_IF_ERROR(shapes_.Merge(s1, s2));
+    if (InferenceContext::Rank(s1) > 0 && InferenceContext::Rank(s2) > 0) {
+      CHECK_EQ(InferenceContext::Rank(s1), InferenceContext::Rank(s2));
+      for (int i = 0; i < InferenceContext::Rank(s1); ++i) {
+        TF_RETURN_IF_ERROR(dims_.Merge(InferenceContext::DimKnownRank(s1, i),
+                                       InferenceContext::DimKnownRank(s2, i)));
+      }
+    }
+    return Status::OK();
+  }
+  Status Merge(DimensionHandle d1, DimensionHandle d2) {
+    if (!d1.IsSet() || !d2.IsSet()) {
+      return Status::OK();
+    }
+    return dims_.Merge(d1, d2);
+  }
+
+  int64 Value(DimensionHandle d) { return dims_.GetMergedValue(d); }
+
+  void AsTensorProperties(const ShapeHandle& shape, const DataType& type,
+                          InferenceContext* ctx,
+                          OpInfo::TensorProperties* properties) {
+    properties->set_dtype(type);
+    if (!ctx->RankKnown(shape)) {
+      properties->mutable_shape()->set_unknown_rank(true);
+    } else {
+      for (int j = 0; j < ctx->Rank(shape); ++j) {
+        shape_inference::DimensionHandle dim = ctx->Dim(shape, j);
+        int64 d = Value(dim);
+        properties->mutable_shape()->add_dim()->set_size(d);
+      }
+    }
+  }
+
+ private:
+  Processor<ShapeHandle> shape_processor_;
+  DisjointSet<shape_inference::ShapeHandle> shapes_;
+  Processor<DimensionHandle> dim_processor_;
+  DisjointSet<shape_inference::DimensionHandle> dims_;
+};
+
 void GraphProperties::Relax(InferenceContext* c, ShapeHandle s0, ShapeHandle s1,
                             ShapeHandle* out) {
   c->Relax(s0, s1, out);
@@ -394,6 +639,37 @@ Status GraphProperties::InferStatically() {
     } while (!done);
   }
 
+  std::unordered_map<const shape_inference::Dimension*, int> dim_ids;
+
+  // Track shapes globally accross the graph.
+  SymbolicShapeManager shape_manager;
+  bool found_error = false;
+  for (const Node* const node : graph.nodes()) {
+    auto node_ctx = shape_refiner.GetContext(node);
+    if (!node_ctx) {
+      continue;
+    }
+    for (const auto& merged_shapes : node_ctx->MergedShapes()) {
+      if (!shape_manager.Merge(merged_shapes.first, merged_shapes.second)
+               .ok()) {
+        found_error = true;
+        break;
+      }
+    }
+    for (const auto& merged_dims : node_ctx->MergedDims()) {
+      if (!shape_manager.Merge(merged_dims.first, merged_dims.second).ok()) {
+        found_error = true;
+        break;
+      }
+    }
+    if (found_error) {
+      // The shapes aren't consistent, we can't infer safely: discard all the
+      // information discovered so far.
+      shape_manager = SymbolicShapeManager();
+      break;
+    }
+  }
+
   for (const Node* const node : graph.nodes()) {
     VLOG(1) << "<Node> " << node->name();
     auto ctx = shape_refiner.GetContext(node);
@@ -411,8 +687,8 @@ Status GraphProperties::InferStatically() {
 
       input_properties.resize(ctx->num_inputs());
       for (int i = 0; i < ctx->num_inputs(); ++i) {
-        FillTensorPropertiesFromContext(ctx->input(i), node->input_type(i), ctx,
-                                        &input_properties[i]);
+        shape_manager.AsTensorProperties(ctx->input(i), node->input_type(i),
+                                         ctx, &input_properties[i]);
       }
       for (const auto& edge : node->in_edges()) {
         if (!edge->src()->IsConstant()) {
@@ -438,8 +714,8 @@ Status GraphProperties::InferStatically() {
 
       output_properties.resize(ctx->num_outputs());
       for (int i = 0; i < ctx->num_outputs(); ++i) {
-        FillTensorPropertiesFromContext(ctx->output(i), node->output_type(i),
-                                        ctx, &output_properties[i]);
+        shape_manager.AsTensorProperties(ctx->output(i), node->output_type(i),
+                                         ctx, &output_properties[i]);
       }
     }
   }
@@ -458,7 +734,7 @@ Status GraphProperties::InferDynamically(Cluster* cluster) {
   return InferFromCostGraph(metadata.cost_graph());
 }
 
-Status GraphProperties::AnnotateOutputShapes(GraphDef* output_graph_def) {
+Status GraphProperties::AnnotateOutputShapes(GraphDef* output_graph_def) const {
   *output_graph_def = item_.graph;
   for (int i = 0; i < output_graph_def->node_size(); i++) {
     auto node = output_graph_def->mutable_node(i);
@@ -531,20 +807,5 @@ GraphProperties::GetOutputProperties(const string& node_name) const {
   return missing_properties_;
 }
 
-void GraphProperties::FillTensorPropertiesFromContext(
-    const ShapeHandle& shape, const DataType& type, InferenceContext* ctx,
-    OpInfo::TensorProperties* properties) {
-  properties->set_dtype(type);
-  if (!ctx->RankKnown(shape)) {
-    properties->mutable_shape()->set_unknown_rank(true);
-  } else {
-    for (int j = 0; j < ctx->Rank(shape); ++j) {
-      shape_inference::DimensionHandle dim = ctx->Dim(shape, j);
-      int64 d = ctx->Value(dim);
-      properties->mutable_shape()->add_dim()->set_size(d);
-    }
-  }
-}
-
 }  // end namespace grappler
 }  // end namespace tensorflow
diff --git a/tensorflow/core/grappler/costs/graph_properties.h b/tensorflow/core/grappler/costs/graph_properties.h
index 5649788be5bfcb94308e84f449b400de9bd76ca2..e2fe9f96892f00350587de7f6f8540329e9f6dc9 100644
--- a/tensorflow/core/grappler/costs/graph_properties.h
+++ b/tensorflow/core/grappler/costs/graph_properties.h
@@ -40,8 +40,14 @@ class GraphProperties {
   Status InferFromCostGraph(const CostGraphDef& cost_graph);
 
   // Stores `item_.graph` with the inferred output shapes to `output_graph_def`.
-  Status AnnotateOutputShapes(GraphDef* output_graph_def);
-
+  Status AnnotateOutputShapes(GraphDef* output_graph_def) const;
+
+  // Return the properties of node inputs/outputs, including data types and
+  // shapes. Note that the dimensions in the shapes can be negative. We use the
+  // -1 value to denote that we don't know anything about a dimension. We use
+  // values strictly less than -1 to encode symbolic dimensions: although we
+  // don't know the actual value of the symbolic dimension, we know that all the
+  // dimensions denoted by the same negative value are the equal.
   bool HasInputProperties(const string& name) const;
   bool HasOutputProperties(const string& name) const;
   const std::vector<OpInfo::TensorProperties>& GetInputProperties(
@@ -51,7 +57,9 @@ class GraphProperties {
 
   static void FillTensorPropertiesFromContext(
       const shape_inference::ShapeHandle&, const DataType&,
-      shape_inference::InferenceContext*, OpInfo::TensorProperties*);
+      shape_inference::InferenceContext*,
+      std::unordered_map<const shape_inference::Dimension*, int>* dim_ids,
+      OpInfo::TensorProperties*);
 
  private:
   // Inputs
diff --git a/tensorflow/core/grappler/costs/graph_properties_test.cc b/tensorflow/core/grappler/costs/graph_properties_test.cc
index 134db5ec5a9ee11949c4ee6f869839e842089740..a33cdacc09289b8953f1a7ac62789b121068e9d3 100644
--- a/tensorflow/core/grappler/costs/graph_properties_test.cc
+++ b/tensorflow/core/grappler/costs/graph_properties_test.cc
@@ -54,7 +54,8 @@ class GraphPropertiesTest : public ::testing::Test {
     } else {
       strings::StrAppend(&s, "[");
       for (int i = 0; i < p.shape().dim_size(); ++i) {
-        strings::StrAppend(&s, i == 0 ? "" : ",", p.shape().dim(i).size());
+        strings::StrAppend(&s, i == 0 ? "" : ",",
+                           std::max<int64>(p.shape().dim(i).size(), -1));
       }
       strings::StrAppend(&s, "]");
     }
@@ -733,6 +734,56 @@ TEST_F(GraphPropertiesTest, FunctionStaticShapeInference) {
   EXPECT_EQ(2, prop.shape().dim(1).size());
 }
 
+TEST_F(GraphPropertiesTest, SymbolicShapes) {
+  // Build a simple graph with placeholders of unknown dimensions. These
+  // dimensions will be encoded symbolically.
+  tensorflow::Scope s = tensorflow::Scope::NewRootScope();
+
+  Output a =
+      ops::Placeholder(s.WithOpName("a"), DT_FLOAT,
+                       ops::Placeholder::Shape(PartialTensorShape({-1, -1})));
+  Output b =
+      ops::Placeholder(s.WithOpName("b"), DT_FLOAT,
+                       ops::Placeholder::Shape(PartialTensorShape({-1})));
+  Output c = ops::Identity(s.WithOpName("c"), a);
+  Output d = ops::Identity(s.WithOpName("d"), b);
+  Output e = ops::Add(s.WithOpName("e"), c, d);
+  Output f = ops::Add(s.WithOpName("f"), a, c);
+
+  GrapplerItem item;
+  TF_CHECK_OK(s.ToGraphDef(&item.graph));
+
+  GraphProperties properties(item);
+  TF_CHECK_OK(properties.InferStatically());
+  const auto shape_a = properties.GetOutputProperties("a").at(0).shape();
+  const auto shape_c = properties.GetOutputProperties("c").at(0).shape();
+  EXPECT_EQ(2, shape_a.dim_size());
+  EXPECT_EQ(shape_a.dim_size(), shape_c.dim_size());
+  EXPECT_GE(-2, shape_a.dim(0).size());
+  EXPECT_EQ(shape_a.dim(0).size(), shape_c.dim(0).size());
+  EXPECT_GE(-2, shape_a.dim(1).size());
+  EXPECT_EQ(shape_a.dim(1).size(), shape_c.dim(1).size());
+
+  const auto shape_b = properties.GetOutputProperties("b").at(0).shape();
+  const auto shape_d = properties.GetOutputProperties("d").at(0).shape();
+  EXPECT_EQ(1, shape_b.dim_size());
+  EXPECT_EQ(shape_b.dim_size(), shape_d.dim_size());
+  EXPECT_GE(-2, shape_b.dim(0).size());
+  EXPECT_NE(shape_a.dim(0).size(), shape_b.dim(0).size());
+  EXPECT_EQ(shape_b.dim(0).size(), shape_d.dim(0).size());
+
+  const auto shape_e = properties.GetOutputProperties("e").at(0).shape();
+  EXPECT_EQ(2, shape_e.dim_size());
+  EXPECT_EQ(shape_e.dim(0).size(), shape_c.dim(0).size());
+  EXPECT_NE(shape_e.dim(1).size(), shape_c.dim(1).size());
+  EXPECT_NE(shape_e.dim(0).size(), shape_d.dim(0).size());
+
+  const auto shape_f = properties.GetOutputProperties("f").at(0).shape();
+  EXPECT_EQ(2, shape_f.dim_size());
+  EXPECT_EQ(shape_f.dim(0).size(), shape_a.dim(0).size());
+  EXPECT_EQ(shape_f.dim(1).size(), shape_a.dim(1).size());
+}
+
 }  // namespace
 }  // namespace grappler
 }  // namespace tensorflow
diff --git a/tensorflow/core/grappler/costs/op_level_cost_estimator.cc b/tensorflow/core/grappler/costs/op_level_cost_estimator.cc
index a2fa847df21a540e2bc0169c887d74dcb40a559d..bd84331b6740d7693c561647669485160435cf48 100644
--- a/tensorflow/core/grappler/costs/op_level_cost_estimator.cc
+++ b/tensorflow/core/grappler/costs/op_level_cost_estimator.cc
@@ -98,7 +98,7 @@ TensorShapeProto MaybeGetMinimumShape(const TensorShapeProto& original_shape,
     }
   } else {
     for (int i = 0; i < shape.dim_size(); i++) {
-      if (shape.dim(i).size() == -1) {
+      if (shape.dim(i).size() < 0) {
         *found_unknown_shapes = true;
         VLOG(2) << "Use minimum dim size 1 because the shape is unknown.";
         // The size of each dimension is at least 1, if unknown.
diff --git a/tensorflow/core/grappler/optimizers/arithmetic_optimizer.cc b/tensorflow/core/grappler/optimizers/arithmetic_optimizer.cc
index f1c31ebb2509fad15a3dac445d09528f9c9d5caa..38af7170b52d3fb744a62a732cf24406b30e6ca0 100644
--- a/tensorflow/core/grappler/optimizers/arithmetic_optimizer.cc
+++ b/tensorflow/core/grappler/optimizers/arithmetic_optimizer.cc
@@ -19,6 +19,7 @@ limitations under the License.
 #include <limits>
 #include <unordered_map>
 #include <unordered_set>
+#include <vector>
 
 #include "tensorflow/core/framework/attr_value.pb.h"
 #include "tensorflow/core/framework/node_def.pb.h"
@@ -30,9 +31,11 @@ limitations under the License.
 #include "tensorflow/core/grappler/optimizers/constant_folding.h"
 #include "tensorflow/core/grappler/utils/frame.h"
 #include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
 #include "tensorflow/core/lib/strings/strcat.h"
 #include "tensorflow/core/platform/tensor_coding.h"
 #include "tensorflow/core/util/device_name_utils.h"
+#include "tensorflow/core/util/saved_tensor_slice_util.h"
 
 namespace tensorflow {
 namespace grappler {
@@ -77,14 +80,25 @@ Status SetTensorValue(DataType dtype, int value, Tensor* tensor) {
   return Status::OK();
 }
 
-static bool IsInvolution(const NodeDef& node) {
-  const std::unordered_set<string> involution_ops = {"Conj", "Reciprocal",
-                                                     "Neg", "LogicalNot"};
+bool IsInvolution(const NodeDef& node) {
+  const std::unordered_set<string> involution_ops = {
+      "Conj", "Reciprocal", "Invert", "Neg", "LogicalNot"};
   return involution_ops.count(node.op()) > 0;
 }
 
-bool AreInversePermutations(gtl::ArraySlice<int32> a,
-                            gtl::ArraySlice<int32> b) {
+// Returns true if the op in node only rearranges the order of elements in an
+// input tensor, or more specifically, if it commutes with all element-wise
+// operations on the values.
+bool IsValuePreserving(const NodeDef& node) {
+  const std::unordered_set<string> value_preserving_ops = {
+      "Transpose",  "Reshape",      "Identity",        "InvertPermutation",
+      "Reverse",    "StopGradient", "PreventGradient", "CheckNumerics",
+      "ExpandDims", "Squeeze"};
+  return value_preserving_ops.count(node.op()) > 0;
+}
+
+template <typename T>
+bool AreInversePermutations(const std::vector<T>& a, const std::vector<T>& b) {
   if (a.size() != b.size()) {
     return false;
   }
@@ -96,50 +110,114 @@ bool AreInversePermutations(gtl::ArraySlice<int32> a,
   return true;
 }
 
-// Extract int32 values from a Const op to `int32_values`. Returns true if
-// succeeds.
-bool Int32ValuesFromNode(const NodeDef& node, std::vector<int>* int32_values) {
+// Extract values from a Const op to `values`. Returns true if succeeds.
+template <typename T>
+bool ValuesFromConstNode(const NodeDef& node, std::vector<T>* values) {
   if (node.op() != "Const") {
     return false;
   }
 
-  if (node.attr().at("dtype").type() != DT_INT32) {
+  if (node.attr().at("dtype").type() != DataTypeToEnum<T>::value) {
     return false;
   }
 
   // TensorProto represents the content of the tensor in either <type>_val or
   // tensor_content.
   const TensorProto& tensor = node.attr().at("value").tensor();
-  if (tensor.int_val_size() > 0 && tensor.has_tensor_shape()) {
+  typename checkpoint::SaveTypeTraits<T>::RepeatedField* tensor_values =
+      checkpoint::MutableTensorProtoData<T>(const_cast<TensorProto*>(&tensor));
+
+  if (!tensor_values->empty() && tensor.has_tensor_shape()) {
     // When tensor_shape is set, theoretically the representation of the data
-    // could be compressed. So, before copying int_val to the returned vector,
+    // could be compressed. So, before copying values to the returned vector,
     // make sure no compression happens.
     const TensorShapeProto& shape = tensor.tensor_shape();
-    if (shape.dim_size() == 1 && shape.dim(0).size() == tensor.int_val_size()) {
-      int32_values->insert(int32_values->end(), tensor.int_val().begin(),
-                           tensor.int_val().end());
+    if (shape.dim_size() == 1 && shape.dim(0).size() == tensor_values->size()) {
+      values->insert(values->end(), tensor_values->begin(),
+                     tensor_values->end());
+      return true;
     }
-    return true;
   }
 
   const auto tensor_content_size = tensor.tensor_content().size();
   if (tensor_content_size > 0) {
-    CHECK_EQ(0, tensor_content_size % sizeof(int32))
+    CHECK_EQ(0, tensor_content_size % sizeof(T))
         << "tensor_content_size (" << tensor_content_size
-        << ") is not a multiple of " << sizeof(int32);
-    int32_values->resize(tensor_content_size / sizeof(int32));
+        << ") is not a multiple of " << sizeof(T);
+    values->resize(tensor_content_size / sizeof(T));
     port::CopyToArray(tensor.tensor_content(),
-                      reinterpret_cast<char*>(int32_values->data()));
+                      reinterpret_cast<char*>(values->data()));
     return true;
   }
 
   return false;
 }
 
+template <typename T>
+bool IsInnerMatrixTranspose(const std::vector<T>& perm) {
+  const T n = perm.size();
+  if (n < 2) {
+    return false;
+  }
+  for (T i = 0; i < n - 2; ++i) {
+    if (perm[i] != i) {
+      return false;
+    }
+  }
+  return perm[n - 1] == n - 2 && perm[n - 2] == n - 1;
+}
+
+bool IsInnerMatrixTransposeNode(const NodeDef& transpose_node,
+                                const NodeMap* node_map) {
+  if (transpose_node.op() != "Transpose" &&
+      transpose_node.op() != "ConjugateTranspose") {
+    return false;
+  }
+  const NodeDef* perm_node = node_map->GetNode(transpose_node.input(1));
+  std::vector<int> perm32;
+  if (ValuesFromConstNode(*perm_node, &perm32)) {
+    return IsInnerMatrixTranspose(perm32);
+  }
+  std::vector<int64> perm64;
+  if (ValuesFromConstNode(*perm_node, &perm64)) {
+    return IsInnerMatrixTranspose(perm64);
+  }
+  return false;
+}
+
 bool SimplyReordersData(const NodeDef& node) {
   return node.op() == "Transpose";
 }
 
+// Follow a chain (through input(0)) of ops starting at `source->input(0)` as
+// long as they
+//  1. preserve the values of their first input,
+//  2. have a single output,
+//  3. are not in nodes_to_preserve.
+// Returns the last node in the chain satisfying these properties or source
+// itself if a chain of length zero was found.
+//
+// source <- vp <- vp <- vp <- non_vp
+//                       ^^
+//                   return value
+NodeDef* GetTailOfValuePreservingChain(
+    const NodeDef* source, const NodeMap* node_map,
+    const std::unordered_set<string>& nodes_to_preserve) {
+  const NodeDef* source_parent = source;
+  source = node_map->GetNode(source->input(0));
+  while (IsValuePreserving(*source) &&
+         node_map->GetOutputs(source->name()).size() == 1 &&
+         // Do not skip over preserved nodes, because folding will change
+         // the results of these skipped data-reordering nodes.
+         // TODO(jingyue): A more elegant way is to copy this chain of
+         // data-reordering nodes and modify only the copy.
+         !nodes_to_preserve.count(source->name())) {
+    source_parent = source;
+    source = node_map->GetNode(source->input(0));
+  }
+  return const_cast<NodeDef*>(source_parent);
+}
+
 // Returns the data type in attribute `attr_name` of `node`. If that attribute
 // doesn't exist, returns DT_INVALID.
 DataType GetDataTypeFromAttr(const NodeDef& node, const string& attr_name) {
@@ -181,6 +259,12 @@ void SetDataTypeToAttr(DataType dtype, const string& attr_name, NodeDef* node) {
   (*node->mutable_attr())[attr_name].set_type(dtype);
 }
 
+void FlipBooleanAttr(const string& attr_name, NodeDef* node) {
+  const bool old_value =
+      !node->attr().count(attr_name) ? false : node->attr().at(attr_name).b();
+  (*node->mutable_attr())[attr_name].set_b(!old_value);
+}
+
 string SourceDataTypeAttrName(const NodeDef& node) {
   if (node.op() == "Bitcast") {
     return "T";
@@ -483,11 +567,26 @@ string ArithmeticOptimizer::TrySimplifyAndReplaceUses(
     std::vector<const NodeDef*>* new_nodes, FrameMap* frame_map) const {
   // Remove involutions applied twice.
   if (IsInvolution(*node)) {
-    // An involution is a function f(x) that is its own inverse,
-    // i.e. f(f(x)) = x.
-    const NodeDef* input = node_map->GetNode(node->input(0));
-    if (input->op() == node->op()) {
-      return input->input(0);
+    // An involution is an element-wise function f(x) that is its own inverse,
+    // i.e. f(f(x)) = x. If we can find a chain of ops
+    //   f->op1->op2->...opn->f
+    // where op1 through opn preserve the values of their inputs, we can remove
+    // the two instances of the involution from the graph, since they cancel
+    // each other.
+    NodeDef* tail =
+        GetTailOfValuePreservingChain(node, node_map, nodes_to_preserve_);
+    NodeDef* involution = node_map->GetNode(tail->input(0));
+    if (involution->op() == node->op()) {
+      // Skip both *node and *involution since they cancel each other.
+      if (tail == node) {
+        // The two nodes to eliminate are adjacent.
+        return involution->input(0);
+      } else {
+        tail->set_input(0, involution->input(0));
+        node_map->UpdateInput(tail->name(), involution->name(),
+                              involution->input(0));
+        return node->input(0);
+      }
     }
   }
 
@@ -497,13 +596,22 @@ string ArithmeticOptimizer::TrySimplifyAndReplaceUses(
     if (input->op() == node->op()) {
       const NodeDef* node_perm = node_map->GetNode(node->input(1));
       const NodeDef* input_perm = node_map->GetNode(input->input(1));
+      // Try 32-bit indices.
       std::vector<int> node_perm_values;
       std::vector<int> input_perm_values;
-      if (Int32ValuesFromNode(*node_perm, &node_perm_values) &&
-          Int32ValuesFromNode(*input_perm, &input_perm_values) &&
+      if (ValuesFromConstNode(*node_perm, &node_perm_values) &&
+          ValuesFromConstNode(*input_perm, &input_perm_values) &&
           AreInversePermutations(node_perm_values, input_perm_values)) {
         return input->input(0);
       }
+      // Try 64-bit indices.
+      std::vector<int64> node_perm_values64;
+      std::vector<int64> input_perm_values64;
+      if (ValuesFromConstNode(*node_perm, &node_perm_values64) &&
+          ValuesFromConstNode(*input_perm, &input_perm_values64) &&
+          AreInversePermutations(node_perm_values64, input_perm_values64)) {
+        return input->input(0);
+      }
     }
   }
 
@@ -673,16 +781,9 @@ string ArithmeticOptimizer::TrySimplifyAndReplaceUses(
     // constant, this should also help performance a bit and memory usage a lot,
     // since the weights tend to be smaller than the activations.
     if (weights->op() == "Const") {
-      const NodeDef* source = node_map->GetNode(node->input(0));
-      while (SimplyReordersData(*source) &&
-             node_map->GetOutputs(source->name()).size() == 1 &&
-             // Do not skip over preserved nodes, because folding will change
-             // the results of these skipped data-reordering nodes.
-             // TODO(jingyue): A more elegant way is to copy this chain of
-             // data-reordering nodes and modify only the copy.
-             !nodes_to_preserve_.count(source->name())) {
-        source = node_map->GetNode(source->input(0));
-      }
+      const NodeDef* source = node_map->GetNode(
+          GetTailOfValuePreservingChain(node, node_map, nodes_to_preserve_)
+              ->input(0));
       if (source->op() == "Mul" &&
           node_map->GetOutputs(source->name()).size() == 1) {
         const NodeDef* mul = source;
@@ -865,12 +966,61 @@ string ArithmeticOptimizer::TrySimplifyAndReplaceUses(
     }
   }
 
-  // Fuse ops by absorbing Conj into Transpose or ConjugateTranspose.
+  // Fold Transpose into matrix multiplication.
+  if ((node->op() == "MatMul" || node->op() == "SparseMatMul" ||
+       node->op() == "BatchMatMul") &&
+      node_map->GetNode(node->name() + "_fused") == nullptr) {
+    const NodeDef* a = node_map->GetNode(node->input(0));
+    const NodeDef* b = node_map->GetNode(node->input(1));
+    bool is_complex = false;
+    if (node->op() != "SparseMatMul") {
+      const DataType type = GetDataTypeFromAttr(*node, "T");
+      is_complex = (type == DT_COMPLEX64) || (type == DT_COMPLEX128);
+    }
+    const std::set<string> foldable_transpose_ops =
+        !is_complex ? std::set<string>{"ConjugateTranspose", "Transpose"}
+                    : (node->op() == "BatchMatMul"
+                           ? std::set<string>{"ConjugateTranspose"}
+                           : std::set<string>{"Transpose"});
+    const bool a_is_foldable = foldable_transpose_ops.count(a->op()) > 0 &&
+                               IsInnerMatrixTransposeNode(*a, node_map);
+    const bool b_is_foldable = foldable_transpose_ops.count(b->op()) > 0 &&
+                               IsInnerMatrixTransposeNode(*b, node_map);
+    if (a_is_foldable || b_is_foldable) {
+      NodeDef* new_op = graph_def->add_node();
+      *new_op = *node;
+      new_op->set_name(node->name() + "_fused");
+      node_map->AddNode(new_op->name(), new_op);
+      if (a_is_foldable) {
+        const string attr_a =
+            node->op() == "BatchMatMul" ? "adj_x" : "transpose_a";
+        FlipBooleanAttr(attr_a, new_op);
+        new_op->set_input(0, a->input(0));
+        node_map->UpdateInput(new_op->name(), a->name(), a->input(0));
+        AddFrameControlDeps(node, {new_op}, a->input(0), {new_op}, graph_def,
+                            node_map, frame_map);
+      }
+      if (b_is_foldable) {
+        const string attr_b =
+            node->op() == "BatchMatMul" ? "adj_y" : "transpose_b";
+        FlipBooleanAttr(attr_b, new_op);
+        new_op->set_input(1, b->input(0));
+        node_map->UpdateInput(new_op->name(), b->name(), b->input(0));
+        if (!a_is_foldable) {
+          AddFrameControlDeps(node, {new_op}, b->input(0), {new_op}, graph_def,
+                              node_map, frame_map);
+        }
+      }
+    }
+  }
+
+  // Fold Conj into Transpose or ConjugateTranspose.
   if (node->op() == "Conj" || node->op() == "Transpose" ||
       node->op() == "ConjugateTranspose") {
     const NodeDef* input = node_map->GetNode(node->input(0));
     const NodeDef* transpose_op = node->op() == "Conj" ? input : node;
     const NodeDef* conj_op = node->op() == "Conj" ? node : input;
+
     if ((transpose_op->op() == "Transpose" ||
          transpose_op->op() == "ConjugateTranspose") &&
         conj_op->op() == "Conj") {
diff --git a/tensorflow/core/grappler/optimizers/arithmetic_optimizer_test.cc b/tensorflow/core/grappler/optimizers/arithmetic_optimizer_test.cc
index c1535886d1366a3e04bb6cea1e6d988598cc4b94..9f471302c7fce9182d5be9f138a79ce7a085f2d6 100644
--- a/tensorflow/core/grappler/optimizers/arithmetic_optimizer_test.cc
+++ b/tensorflow/core/grappler/optimizers/arithmetic_optimizer_test.cc
@@ -131,6 +131,27 @@ TEST_F(ArithmeticOptimizerTest, SimplifyInvolutionsReal) {
   EXPECT_EQ("c", output.node(5).input(0));
 }
 
+TEST_F(ArithmeticOptimizerTest, SimplifyInvolutionsWithChain) {
+  tensorflow::Scope s = tensorflow::Scope::NewRootScope();
+  Output c = ops::Const(s.WithOpName("c"), {1.0f, 2.0f}, {1, 2});
+  Output recip1 = ops::Reciprocal(s.WithOpName("recip1"), c);
+  Output id1 = ops::Identity(s.WithOpName("id1"), recip1);
+  Output squeeze = ops::Squeeze(s.WithOpName("squeeze"), id1);
+  Output recip2 = ops::Reciprocal(s.WithOpName("recip2"), squeeze);
+  Output id2 = ops::Identity(s.WithOpName("id2"), recip2);
+  GrapplerItem item;
+  TF_CHECK_OK(s.ToGraphDef(&item.graph));
+
+  ArithmeticOptimizer optimizer;
+  GraphDef output;
+  Status status = optimizer.Optimize(nullptr, item, &output);
+  TF_EXPECT_OK(status);
+
+  EXPECT_EQ(6, output.node_size());
+  EXPECT_EQ("squeeze", output.node(5).input(0));
+  EXPECT_EQ("c", output.node(2).input(0));
+}
+
 TEST_F(ArithmeticOptimizerTest, SimplifyReplaceTrivialSums) {
   tensorflow::Scope s = tensorflow::Scope::NewRootScope();
   Output x = ops::Const(s.WithOpName("x"), {1.0f, 2.0f}, {1, 2});
@@ -145,7 +166,6 @@ TEST_F(ArithmeticOptimizerTest, SimplifyReplaceTrivialSums) {
   Status status = optimizer.Optimize(nullptr, item, &output);
   TF_EXPECT_OK(status);
 
-  //  VLOG(2) << output.DebugString();
   EXPECT_EQ(5, output.node_size());
   const NodeDef& new_const = output.node(3);
   EXPECT_EQ("add_const", new_const.name());
@@ -176,7 +196,6 @@ TEST_F(ArithmeticOptimizerTest, SimplifyHoistFactor) {
   Status status = optimizer.Optimize(nullptr, item, &output);
   TF_EXPECT_OK(status);
 
-  LOG(INFO) << output.DebugString();
   EXPECT_EQ(9, output.node_size());
   const NodeDef& new_add = output.node(8);
   EXPECT_EQ("add_hoist", new_add.name());
@@ -206,7 +225,6 @@ TEST_F(ArithmeticOptimizerTest, FuseConjAndTranspose) {
   GraphDef output;
   Status status = optimizer.Optimize(nullptr, item, &output);
   TF_EXPECT_OK(status);
-  LOG(INFO) << output.DebugString();
 
   EXPECT_EQ(7, output.node_size());
   EXPECT_EQ("trans_fused", output.node(6).name());
@@ -231,7 +249,6 @@ TEST_F(ArithmeticOptimizerTest, FuseConjAndConjugateTranspose) {
   GraphDef output;
   Status status = optimizer.Optimize(nullptr, item, &output);
   TF_EXPECT_OK(status);
-  LOG(INFO) << output.DebugString();
 
   EXPECT_EQ(7, output.node_size());
   EXPECT_EQ("conjugate_trans_fused", output.node(6).name());
@@ -255,7 +272,6 @@ TEST_F(ArithmeticOptimizerTest, FuseTransposeAndConj) {
   GraphDef output;
   Status status = optimizer.Optimize(nullptr, item, &output);
   TF_EXPECT_OK(status);
-  LOG(INFO) << output.DebugString();
 
   EXPECT_EQ(7, output.node_size());
   EXPECT_EQ("conj_fused", output.node(6).name());
@@ -264,6 +280,77 @@ TEST_F(ArithmeticOptimizerTest, FuseTransposeAndConj) {
   EXPECT_EQ("perm", output.node(6).input(1));
 }
 
+TEST_F(ArithmeticOptimizerTest, FoldTransposeIntoMatMul) {
+  for (const string matmul_type : {"MatMul", "SparseMatMul", "BatchMatMul"}) {
+    tensorflow::Scope s = tensorflow::Scope::NewRootScope();
+    Output a = ops::Const(s.WithOpName("a"), {1.0f, 2.0f, 3.0f, 4.0f}, {2, 2});
+    Output b = ops::Const(s.WithOpName("b"), {5.0f, 6.0f, 7.0f, 8.0f}, {2, 2});
+    Output perm = ops::Const(s.WithOpName("perm"), {1, 0}, {2});
+    Output trans_a = ops::Transpose(s.WithOpName("trans_a"), a, perm);
+    Output trans_b = ops::Transpose(s.WithOpName("trans_b"), b, perm);
+    if (matmul_type == "MatMul") {
+      Output matmul = ops::MatMul(s.WithOpName("matmul"), trans_a, trans_b);
+    } else if (matmul_type == "SparseMatMul") {
+      Output matmul =
+          ops::SparseMatMul(s.WithOpName("matmul"), trans_a, trans_b);
+    } else if (matmul_type == "BatchMatMul") {
+      Output matmul =
+          ops::BatchMatMul(s.WithOpName("matmul"), trans_a, trans_b);
+    }
+    GrapplerItem item;
+    TF_CHECK_OK(s.ToGraphDef(&item.graph));
+
+    ArithmeticOptimizer optimizer;
+    GraphDef output;
+    Status status = optimizer.Optimize(nullptr, item, &output);
+    TF_EXPECT_OK(status);
+
+    EXPECT_EQ(7, output.node_size());
+    EXPECT_EQ("matmul_fused", output.node(6).name());
+    EXPECT_EQ("a", output.node(6).input(0));
+    EXPECT_EQ("b", output.node(6).input(1));
+    if (matmul_type == "BatchMatMul") {
+      EXPECT_TRUE(output.node(6).attr().at("adj_x").b());
+      EXPECT_TRUE(output.node(6).attr().at("adj_y").b());
+    } else {
+      EXPECT_TRUE(output.node(6).attr().at("transpose_a").b());
+      EXPECT_TRUE(output.node(6).attr().at("transpose_b").b());
+    }
+  }
+}
+
+TEST_F(ArithmeticOptimizerTest, FoldConjugateTransposeIntoBatchMatMul) {
+  tensorflow::Scope s = tensorflow::Scope::NewRootScope();
+  Output re_a =
+      ops::Const(s.WithOpName("re_a"), {1.0f, 2.0f, 3.0f, 4.0f}, {2, 2});
+  Output im_a =
+      ops::Const(s.WithOpName("im_a"), {-1.0f, -2.0f, -3.0f, -4.0f}, {2, 2});
+  Output re_b =
+      ops::Const(s.WithOpName("re_b"), {5.0f, 6.0f, 7.0f, 8.0f}, {2, 2});
+  Output im_b =
+      ops::Const(s.WithOpName("im_b"), {-5.0f, -6.0f, -7.0f, -8.0f}, {2, 2});
+  Output a = ops::Complex(s.WithOpName("a"), re_a, im_a);
+  Output b = ops::Complex(s.WithOpName("b"), re_b, im_b);
+  Output perm = ops::Const(s.WithOpName("perm"), {1, 0}, {2});
+  Output trans_a = ops::ConjugateTranspose(s.WithOpName("trans_a"), a, perm);
+  Output trans_b = ops::ConjugateTranspose(s.WithOpName("trans_b"), b, perm);
+  Output matmul = ops::BatchMatMul(s.WithOpName("matmul"), trans_a, trans_b);
+  GrapplerItem item;
+  TF_CHECK_OK(s.ToGraphDef(&item.graph));
+
+  ArithmeticOptimizer optimizer;
+  GraphDef output;
+  Status status = optimizer.Optimize(nullptr, item, &output);
+  TF_EXPECT_OK(status);
+
+  EXPECT_EQ(11, output.node_size());
+  EXPECT_EQ("matmul_fused", output.node(10).name());
+  EXPECT_EQ("a", output.node(10).input(0));
+  EXPECT_EQ("b", output.node(10).input(1));
+  EXPECT_TRUE(output.node(10).attr().at("adj_x").b());
+  EXPECT_TRUE(output.node(10).attr().at("adj_y").b());
+}
+
 TEST_F(ArithmeticOptimizerTest, IdentityReshape) {
   tensorflow::Scope s = tensorflow::Scope::NewRootScope();
   Output inputs =
diff --git a/tensorflow/core/grappler/optimizers/constant_folding.cc b/tensorflow/core/grappler/optimizers/constant_folding.cc
index e8ffff07c6f420cc6f4bead5e86ed43c1f3acec0..cb023141833096b2e34df558f1542d492ab9c25b 100644
--- a/tensorflow/core/grappler/optimizers/constant_folding.cc
+++ b/tensorflow/core/grappler/optimizers/constant_folding.cc
@@ -914,8 +914,8 @@ Status ConstantFolding::RunOptimizationPass(Cluster* cluster,
   // new names, and as a result users would not be able to fetch the node any
   // more with the original node name.
   for (const auto& fetch : item.fetch) {
-    auto fetch_node = node_map_->GetNode(fetch);
-    if (NumOutputs(*fetch_node) == 1) {
+    const NodeDef* fetch_node = node_map_->GetNode(fetch);
+    if (fetch_node && NumOutputs(*fetch_node) == 1) {
       nodes_whitelist_.insert(fetch_node->name());
     }
   }
diff --git a/tensorflow/core/grappler/optimizers/layout_optimizer.cc b/tensorflow/core/grappler/optimizers/layout_optimizer.cc
index 1ca296da0a0637655ec067adfd367205a62c6484..e2e4bc3de803ac67cbf61aff2a6560d044043415 100644
--- a/tensorflow/core/grappler/optimizers/layout_optimizer.cc
+++ b/tensorflow/core/grappler/optimizers/layout_optimizer.cc
@@ -20,7 +20,6 @@ limitations under the License.
 #include "tensorflow/core/framework/tensor.pb.h"
 #include "tensorflow/core/framework/tensor_shape.pb.h"
 #include "tensorflow/core/grappler/clusters/cluster.h"
-#include "tensorflow/core/grappler/costs/graph_properties.h"
 #include "tensorflow/core/grappler/devices.h"
 #include "tensorflow/core/grappler/grappler_item.h"
 #include "tensorflow/core/grappler/op_types.h"
@@ -61,23 +60,12 @@ std::set<string> GetOpsFormatSupported() {
 }
 
 std::set<string> GetOpsFormatAgnostic() {
-  std::set<string> ops_format_agnostic = {"Add",
-                                          "AddN",
-                                          "Concat",
-                                          "ConcatV2",
-                                          "Floor",
-                                          "Identity",
-                                          "Mul",
-                                          "Neg",
-                                          "RealDiv",
-                                          "Relu",
-                                          "Relu6",
-                                          "ReluGrad",
-                                          "Sigmoid",
-                                          "Slice",
-                                          "SquaredDifference",
-                                          "Squeeze",
-                                          "Sub"};
+  std::set<string> ops_format_agnostic = {
+      "Add",      "AddN",     "Concat", "ConcatV2",
+      "Floor",    "Identity", "Mul",    "Neg",
+      "Pad",      "RealDiv",  "Relu",   "Relu6",
+      "ReluGrad", "Sigmoid",  "Slice",  "SquaredDifference",
+      "Squeeze",  "Sub"};
   return ops_format_agnostic;
 }
 
@@ -279,10 +267,23 @@ class NodeProcessor : public GraphProcessor {
     if (!success) {
       LOG(ERROR) << "Failed to parse TensorProto.";
     }
-    int c = tensor.flat<int>()(3);
-    tensor.flat<int>()(3) = tensor.flat<int>()(2);
-    tensor.flat<int>()(2) = tensor.flat<int>()(1);
-    tensor.flat<int>()(1) = c;
+    if (tensor.dims() == 1) {
+      int c = tensor.flat<int>()(3);
+      tensor.flat<int>()(3) = tensor.flat<int>()(2);
+      tensor.flat<int>()(2) = tensor.flat<int>()(1);
+      tensor.flat<int>()(1) = c;
+    } else if (tensor.dims() == 2) {
+      for (int i = 0; i < 2; i++) {
+        int c = tensor.matrix<int>()(3, i);
+        tensor.matrix<int>()(3, i) = tensor.matrix<int>()(2, i);
+        tensor.matrix<int>()(2, i) = tensor.matrix<int>()(1, i);
+        tensor.matrix<int>()(1, i) = c;
+      }
+    } else {
+      return Status(
+          error::INVALID_ARGUMENT,
+          strings::StrCat("Unsupported dimension size: ", tensor.dims()));
+    }
     tensor.AsProtoTensorContent(
         node->mutable_attr()->at({"value"}).mutable_tensor());
     return Status::OK();
@@ -290,6 +291,8 @@ class NodeProcessor : public GraphProcessor {
 
   Status UpdateAttrValueOfInput(int input_index) {
     auto input_node = node_map_->GetNode(node_->input(input_index));
+    // We created a copy of the node, so that we don't modify the original node,
+    // which might be used elsewhere.
     NodeDef* added_node = graph_->add_node();
     *added_node = *input_node;
     string base_name = strings::StrCat(node_->name(), "-", input_node->name());
@@ -876,6 +879,38 @@ class ConcatProcessor : public AgnosticNodeProcessor {
   }
 };
 
+class PadProcessor : public AgnosticNodeProcessor {
+ public:
+  PadProcessor(GraphDef* graph, NodeDef* node, NodeMap* node_map,
+               bool is_in_frame)
+      : AgnosticNodeProcessor(graph, node, node_map, is_in_frame) {}
+
+ protected:
+  bool ShouldProcess() const override {
+    return IsDimsFour(*node_) && HasOutputs() && IsNodeAfterNCHWToNHWC() &&
+           PaddingSupported();
+  }
+  Status CustomizedProcessing() override { return UpdateAttrValueOfInput(1); }
+
+ private:
+  bool PaddingSupported() const {
+    auto pad_const = node_map_->GetNode(node_->input(1));
+    bool is_const = IsConstant(*pad_const);
+    bool is_4D = false;
+    if (HasAttribute(*pad_const, "value").ok()) {
+      Tensor tensor;
+      if (tensor.FromProto(pad_const->mutable_attr()->at({"value"}).tensor())) {
+        if (tensor.dims() == 2) {
+          if (tensor.dim_size(0) == 4 && tensor.dim_size(1) == 2) {
+            is_4D = true;
+          }
+        }
+      }
+    }
+    return is_const && is_4D;
+  }
+};
+
 class ReluGradProcessor : public AgnosticNodeProcessor {
  public:
   ReluGradProcessor(GraphDef* graph, NodeDef* node, NodeMap* node_map,
@@ -1179,21 +1214,11 @@ class SumProcessor : public AgnosticNodeProcessor {
   }
 };
 
-struct TuningConfig {
-  // If true, do not use the NHWC GEMM implementation. When filter size is
-  // one or filter size is equal to input image size,
-  // the NHWC implementation of Conv2D, Conv2DBackpropInput, and
-  // Conv2DBackpropFilter will use a specialized GEMM implementation, which is
-  // usually faster than the NCHW implementation. The downside is that this
-  // might result in more non-cancellable layout conversion nodes (implemented
-  // by the Transpose op).
-  bool no_gemm;
-};
-
 class DataLayoutOptimizer : GraphProcessor {
  public:
   explicit DataLayoutOptimizer(const string& default_device, GraphDef* graph,
-                               NodeMap* node_map, TuningConfig config)
+                               NodeMap* node_map,
+                               LayoutOptimizer::TuningConfig config)
       : GraphProcessor(graph, node_map),
         default_device_(default_device),
         config_(config) {}
@@ -1303,6 +1328,9 @@ class DataLayoutOptimizer : GraphProcessor {
                      node->op().compare("ConcatV2") == 0) {
             node_processor.reset(
                 new ConcatProcessor(graph_, node, node_map_, is_in_frame));
+          } else if (node->op().compare("Pad") == 0) {
+            node_processor.reset(
+                new PadProcessor(graph_, node, node_map_, is_in_frame));
           } else if (node->op().compare("ReluGrad") == 0) {
             node_processor.reset(
                 new ReluGradProcessor(graph_, node, node_map_, is_in_frame));
@@ -1375,7 +1403,7 @@ class DataLayoutOptimizer : GraphProcessor {
   }
 
   string default_device_;
-  TuningConfig config_;
+  LayoutOptimizer::TuningConfig config_;
 };
 
 int GetNumTranspose(const GraphDef& graph) {
@@ -1389,6 +1417,22 @@ int GetNumTranspose(const GraphDef& graph) {
   return number;
 }
 
+Status LayoutOptimizer::Tune(const GrapplerItem& item,
+                             const GraphProperties& graph_properties,
+                             const string& default_device,
+                             const TuningConfig& config, GraphDef* output) {
+  auto status = graph_properties.AnnotateOutputShapes(output);
+  if (!status.ok()) {
+    *output = item.graph;
+    return status;
+  }
+  NodeMap node_map(output);
+  DataLayoutOptimizer layout_optimizer(default_device, output, &node_map,
+                                       config);
+  status = layout_optimizer.Optimize();
+  return status;
+}
+
 Status LayoutOptimizer::Optimize(Cluster* cluster, const GrapplerItem& item,
                                  GraphDef* output) {
   if (num_gpus_ == 0) {
@@ -1406,11 +1450,6 @@ Status LayoutOptimizer::Optimize(Cluster* cluster, const GrapplerItem& item,
     *output = item.graph;
     return status;
   }
-  status = graph_properties.AnnotateOutputShapes(output);
-  if (!status.ok()) {
-    *output = item.graph;
-    return status;
-  }
 
   TuningConfig config;
   config.no_gemm = false;
@@ -1420,19 +1459,14 @@ Status LayoutOptimizer::Optimize(Cluster* cluster, const GrapplerItem& item,
       default_device = cluster->GetDevices().begin()->first;
     }
   }
-  std::unique_ptr<NodeMap> node_map(new NodeMap(output));
-  std::unique_ptr<DataLayoutOptimizer> layout_optimizer(
-      new DataLayoutOptimizer(default_device, output, node_map.get(), config));
-  status = layout_optimizer->Optimize();
+
+  status = Tune(item, graph_properties, default_device, config, output);
   // This is based on an empirical observation that if the introduced Transpose
   // nodes is more than 30, not using GEMM implementation would result in better
   // performance.
   if (status.ok() && GetNumTranspose(*output) > 30) {
     config.no_gemm = true;
-    node_map.reset(new NodeMap(output));
-    layout_optimizer.reset(new DataLayoutOptimizer(default_device, output,
-                                                   node_map.get(), config));
-    status = layout_optimizer->Optimize();
+    status = Tune(item, graph_properties, default_device, config, output);
   }
 
   if (!status.ok()) {
diff --git a/tensorflow/core/grappler/optimizers/layout_optimizer.h b/tensorflow/core/grappler/optimizers/layout_optimizer.h
index 1bd6f9544b1da87fc86201aef67f151cd06c7124..621c286976a8112538cf2923103ee72ccee2752c 100644
--- a/tensorflow/core/grappler/optimizers/layout_optimizer.h
+++ b/tensorflow/core/grappler/optimizers/layout_optimizer.h
@@ -16,11 +16,11 @@ limitations under the License.
 #ifndef TENSORFLOW_GRAPPLER_OPTIMIZERS_LAYOUT_OPTIMIZER_H_
 #define TENSORFLOW_GRAPPLER_OPTIMIZERS_LAYOUT_OPTIMIZER_H_
 
+#include "tensorflow/core/grappler/costs/graph_properties.h"
 #include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
 
 namespace tensorflow {
 namespace grappler {
-
 // Convert the NHWC layout to NCHW for Conv-related ops on GPUs.
 class LayoutOptimizer : public GraphOptimizer {
  public:
@@ -32,6 +32,17 @@ class LayoutOptimizer : public GraphOptimizer {
   // This is for testing only.
   void set_num_gpus(int num_gpus) { num_gpus_ = num_gpus; };
 
+  struct TuningConfig {
+    // If true, do not use the NHWC GEMM implementation. When filter size is
+    // one or filter size is equal to input image size,
+    // the NHWC implementation of Conv2D, Conv2DBackpropInput, and
+    // Conv2DBackpropFilter will use a specialized GEMM implementation, which is
+    // usually faster than the NCHW implementation. The downside is that this
+    // might result in more non-cancellable layout conversion nodes (implemented
+    // by the Transpose op).
+    bool no_gemm;
+  };
+
   Status Optimize(Cluster* cluster, const GrapplerItem& item,
                   GraphDef* output) override;
 
@@ -40,6 +51,9 @@ class LayoutOptimizer : public GraphOptimizer {
 
  private:
   int num_gpus_ = 0;
+  Status Tune(const GrapplerItem& item, const GraphProperties& graph_properties,
+              const string& default_device, const TuningConfig& config,
+              GraphDef* output);
 };
 
 }  // end namespace grappler
diff --git a/tensorflow/core/grappler/optimizers/layout_optimizer_test.cc b/tensorflow/core/grappler/optimizers/layout_optimizer_test.cc
index 7ebc9aaf1c18607e45e1b70a46552aec94bf35d7..e9febd7e1881ec3ce99a2a10688fb39a597a46bb 100644
--- a/tensorflow/core/grappler/optimizers/layout_optimizer_test.cc
+++ b/tensorflow/core/grappler/optimizers/layout_optimizer_test.cc
@@ -200,6 +200,34 @@ TEST_F(LayoutOptimizerTest, NotEqualSizeWithValidPadding) {
       node_map.GetNode("LayoutOptimizerTransposeNHWCToNCHW-Conv2D-Input-0"));
 }
 
+TEST_F(LayoutOptimizerTest, Pad) {
+  tensorflow::Scope s = tensorflow::Scope::NewRootScope();
+  auto conv = SimpleConv2D(&s, 3, 2, "VALID");
+  auto c = ops::Const(s.WithOpName("c"), {1, 2, 3, 4, 5, 6, 7, 8}, {4, 2});
+  auto p = ops::Pad(s.WithOpName("p"), conv, c);
+  auto o = ops::Identity(s.WithOpName("o"), p);
+  GrapplerItem item;
+  TF_CHECK_OK(s.ToGraphDef(&item.graph));
+  LayoutOptimizer optimizer;
+  optimizer.set_num_gpus(1);
+  GraphDef output;
+  Status status = optimizer.Optimize(nullptr, item, &output);
+  NodeMap node_map(&output);
+
+  auto pad = node_map.GetNode("p");
+  EXPECT_EQ(pad->input(0), "Conv2D");
+
+  auto pad_const = node_map.GetNode("LayoutOptimizer-p-c");
+  EXPECT_TRUE(pad_const);
+  EXPECT_TRUE(pad_const->attr().find("value") != pad_const->attr().end());
+  Tensor tensor;
+  EXPECT_TRUE(
+      tensor.FromProto(pad_const->mutable_attr()->at({"value"}).tensor()));
+  Tensor tensor_expected(DT_INT32, {4, 2});
+  test::FillValues<int>(&tensor_expected, {1, 2, 7, 8, 3, 4, 5, 6});
+  test::ExpectTensorEqual<int>(tensor_expected, tensor);
+}
+
 }  // namespace
 }  // namespace grappler
 }  // namespace tensorflow
diff --git a/tensorflow/core/grappler/optimizers/meta_optimizer.cc b/tensorflow/core/grappler/optimizers/meta_optimizer.cc
index 1174a390f354c696ad762e6b1bda4b2c65261791..a9875c06d8b1f417d9d22b49f6cbdaaae5fbe9f7 100644
--- a/tensorflow/core/grappler/optimizers/meta_optimizer.cc
+++ b/tensorflow/core/grappler/optimizers/meta_optimizer.cc
@@ -110,27 +110,65 @@ Status MetaOptimizer::Optimize(Cluster* cluster, const GrapplerItem& item,
   bool already_optimized = false;
   for (const auto& optimizer : optimizers) {
     if (!already_optimized) {
-      TF_RETURN_IF_ERROR(optimizer->Optimize(cluster, item, optimized_graph));
-      already_optimized = true;
+      auto status = optimizer->Optimize(cluster, item, optimized_graph);
+      string result;
+      if (!status.ok()) {
+        VLOG(1) << "Not able to apply optimizer " << optimizer->name()
+                << ". Return status: " << status.ToString();
+        result = status.ToString();
+      } else {
+        already_optimized = true;
+        result = strings::StrCat(
+            "OK. "
+            "Graph size before: ",
+            item.graph.node_size(),
+            ". Graph size after: ", optimized_graph->node_size());
+      }
+      result_.push_back(std::make_pair(optimizer->name(), result));
     } else {
       GrapplerItem optimized_item(item, std::move(*optimized_graph));
-      TF_RETURN_IF_ERROR(
-          optimizer->Optimize(cluster, optimized_item, optimized_graph));
+      auto status =
+          optimizer->Optimize(cluster, optimized_item, optimized_graph);
+      string result;
+      if (!status.ok()) {
+        VLOG(1) << "Not able to apply optimizer " << optimizer->name()
+                << ". Return status: " << status.ToString();
+        optimized_graph->Swap(&optimized_item.graph);
+        result = status.ToString();
+      } else {
+        result = strings::StrCat(
+            "OK. "
+            "Graph size before: ",
+            optimized_item.graph.node_size(),
+            ". Graph size after: ", optimized_graph->node_size());
+      }
+      result_.push_back(std::make_pair(optimizer->name(), result));
     }
   }
-  TopologicalSort(optimized_graph);
 
-  // Make sure that the optimizers preserved the graph version and library.
-  DCHECK_GE(optimized_graph->library().function_size(),
-            item.graph.library().function_size());
-  DCHECK_GE(optimized_graph->library().gradient_size(),
-            item.graph.library().gradient_size());
-  DCHECK_EQ(optimized_graph->versions().producer(),
-            item.graph.versions().producer());
+  if (already_optimized) {
+    TopologicalSort(optimized_graph);
+    // Make sure that the optimizers preserved the graph version and library.
+    DCHECK_GE(optimized_graph->library().function_size(),
+              item.graph.library().function_size());
+    DCHECK_GE(optimized_graph->library().gradient_size(),
+              item.graph.library().gradient_size());
+    DCHECK_EQ(optimized_graph->versions().producer(),
+              item.graph.versions().producer());
+  } else {
+    *optimized_graph = item.graph;
+  }
 
   return Status::OK();
 }
 
+void MetaOptimizer::PrintResult() {
+  for (const auto& result : result_) {
+    LOG(INFO) << "Return status of optimizer " << result.first << ": "
+              << result.second;
+  }
+}
+
 void MetaOptimizer::Feedback(Cluster* cluster, const GrapplerItem& item,
                              const GraphDef& pruned_graph, double result) {
   // Nothing to do for MetaOptimizer.
diff --git a/tensorflow/core/grappler/optimizers/meta_optimizer.h b/tensorflow/core/grappler/optimizers/meta_optimizer.h
index b00886b964b91e78672f6023c8d5d43ce989de49..382cfe51d42439691fcedd5b765c9ef13e055ae5 100644
--- a/tensorflow/core/grappler/optimizers/meta_optimizer.h
+++ b/tensorflow/core/grappler/optimizers/meta_optimizer.h
@@ -37,6 +37,8 @@ class MetaOptimizer : public GraphOptimizer {
   Status Optimize(Cluster* cluster, const GrapplerItem& item,
                   GraphDef* optimized_graph) override;
 
+  void PrintResult();
+
   void Feedback(Cluster* cluster, const GrapplerItem& item,
                 const GraphDef& optimized_graph, double result) override;
 
@@ -44,6 +46,7 @@ class MetaOptimizer : public GraphOptimizer {
   std::unique_ptr<GraphOptimizer> NewOptimizer(const string& optimizer);
   DeviceBase* const cpu_device_;  // may be NULL
   RewriterConfig cfg_;
+  std::vector<std::pair<string, string>> result_;
 };
 
 bool MetaOptimizerEnabled(const RewriterConfig& cfg);
diff --git a/tensorflow/core/grappler/utils.cc b/tensorflow/core/grappler/utils.cc
index df6c0b9b1b9cd67ea7389bf4a6ac6ff5ef9795d1..54be02b5f8b7f8a1017dee0873bb6859277c769b 100644
--- a/tensorflow/core/grappler/utils.cc
+++ b/tensorflow/core/grappler/utils.cc
@@ -32,7 +32,9 @@ NodeMap::NodeMap(GraphDef* graph) : graph_(graph) {
     auto node = graph_->mutable_node(i);
     auto rslt = nodes_.insert(std::make_pair(node->name(), node));
     // Check that the graph doesn't contain multiple nodes with the same name.
-    CHECK(rslt.second);
+    if (!rslt.second) {
+      LOG(WARNING) << "Duplicated node in the graph: " << node->name();
+    }
     for (const auto& input : node->input()) {
       outputs_[NodeName(input)].insert(nodes_[node->name()]);
     }
@@ -43,6 +45,7 @@ NodeDef* NodeMap::GetNode(const string& name) const {
   string node_name = NodeName(name);
   auto it = nodes_.find(node_name);
   if (it == nodes_.end()) {
+    LOG(WARNING) << "Node " << node_name << " is not in the graph.";
     return nullptr;
   }
   return it->second;
diff --git a/tensorflow/core/kernels/BUILD b/tensorflow/core/kernels/BUILD
index f9020ef08ee86d81689911c9b1a4aff791c654c0..bcc026f4761374347ce13735d74984061ac73e02 100644
--- a/tensorflow/core/kernels/BUILD
+++ b/tensorflow/core/kernels/BUILD
@@ -2277,6 +2277,7 @@ cc_library(
         ":cholesky_grad",
         ":cholesky_op",
         ":determinant_op",
+        ":matrix_exponential_op",
         ":matrix_inverse_op",
         ":matrix_solve_ls_op",
         ":matrix_solve_op",
@@ -2343,6 +2344,12 @@ tf_kernel_library(
     ]) + LINALG_DEPS,
 )
 
+tf_kernel_library(
+    name = "matrix_exponential_op",
+    prefix = "matrix_exponential_op",
+    deps = LINALG_DEPS,
+)
+
 tf_kernel_library(
     name = "self_adjoint_eig_op",
     prefix = "self_adjoint_eig_op",
diff --git a/tensorflow/core/kernels/cwise_op_acosh.cc b/tensorflow/core/kernels/cwise_op_acosh.cc
index 7bdd8d22a3e9f7b064f147ee31b562b68f281c65..39c8814073382566bc3551fdf6d5afc7f1ef0012 100644
--- a/tensorflow/core/kernels/cwise_op_acosh.cc
+++ b/tensorflow/core/kernels/cwise_op_acosh.cc
@@ -20,16 +20,8 @@ namespace tensorflow {
 REGISTER4(UnaryOp, CPU, "Acosh", functor::acosh, float, double,
           complex64, complex128);
 
-#if TENSORFLOW_USE_SYCL
-#define REGISTER_SYCL_KERNEL(TYPE)                                    \
-  REGISTER_KERNEL_BUILDER(                                            \
-                          Name("Acosh")                               \
-                          .Device(DEVICE_SYCL)                        \
-                          .TypeConstraint<TYPE>("T"),                 \
-                          UnaryOp<SYCLDevice, functor::acosh<TYPE>>);
-REGISTER_SYCL_KERNEL(float);
-REGISTER_SYCL_KERNEL(double);
-#undef REGISTER_SYCL_KERNEL
+#ifdef TENSORFLOW_USE_SYCL
+REGISTER2(UnaryOp, SYCL, "Acosh", functor::acosh, float, double);
 #endif // TENSORFLOW_USE_SYCL
 
 #if GOOGLE_CUDA
diff --git a/tensorflow/core/kernels/cwise_op_asinh.cc b/tensorflow/core/kernels/cwise_op_asinh.cc
index e0644323c0052e50e766cdb49c6ed172b88cd326..8d44208aa7d99723670aca20c740cb483479af63 100644
--- a/tensorflow/core/kernels/cwise_op_asinh.cc
+++ b/tensorflow/core/kernels/cwise_op_asinh.cc
@@ -20,17 +20,9 @@ namespace tensorflow {
 REGISTER4(UnaryOp, CPU, "Asinh", functor::asinh, float, double,
           complex64, complex128);
 
-#if TENSORFLOW_USE_SYCL
-#define REGISTER_SYCL_KERNEL(TYPE)                                    \
-  REGISTER_KERNEL_BUILDER(                                            \
-                          Name("Asinh")                               \
-                          .Device(DEVICE_SYCL)                        \
-                          .TypeConstraint<TYPE>("T"),                 \
-                          UnaryOp<SYCLDevice, functor::asinh<TYPE>>);
-REGISTER_SYCL_KERNEL(float);
-REGISTER_SYCL_KERNEL(double);
-#undef REGISTER_SYCL_KERNEL
-#endif // TENSORFLOW_USE_SYC
+#ifdef TENSORFLOW_USE_SYCL
+REGISTER2(UnaryOp, SYCL, "Asinh", functor::asinh, float, double);
+#endif // TENSORFLOW_USE_SYCL
 
 #if GOOGLE_CUDA
 REGISTER2(UnaryOp, GPU, "Asinh", functor::asinh, float, double);
diff --git a/tensorflow/core/kernels/cwise_op_atanh.cc b/tensorflow/core/kernels/cwise_op_atanh.cc
index 058f5140c5bed7f312bf220d665da8628ca657e1..bbc69e45aac5bdc8ae8e3d0f78d07065682b8cc5 100644
--- a/tensorflow/core/kernels/cwise_op_atanh.cc
+++ b/tensorflow/core/kernels/cwise_op_atanh.cc
@@ -20,17 +20,9 @@ namespace tensorflow {
 REGISTER4(UnaryOp, CPU, "Atanh", functor::atanh, float, double,
           complex64, complex128);
 
-#if TENSORFLOW_USE_SYCL
-#define REGISTER_SYCL_KERNEL(TYPE)                                    \
-  REGISTER_KERNEL_BUILDER(                                            \
-                          Name("Atanh")                               \
-                          .Device(DEVICE_SYCL)                        \
-                          .TypeConstraint<TYPE>("T"),                 \
-                          UnaryOp<SYCLDevice, functor::atanh<TYPE>>);
-REGISTER_SYCL_KERNEL(float);
-REGISTER_SYCL_KERNEL(double);
-#undef REGISTER_SYCL_KERNEL
-#endif // TENSORFLOW_USE_SYC
+#ifdef TENSORFLOW_USE_SYCL
+REGISTER2(UnaryOp, SYCL, "Atanh", functor::atanh, float, double);
+#endif // TENSORFLOW_USE_SYCL
 
 #if GOOGLE_CUDA
 REGISTER2(UnaryOp, GPU, "Atanh", functor::atanh, float, double);
diff --git a/tensorflow/core/kernels/cwise_ops.h b/tensorflow/core/kernels/cwise_ops.h
index 6c22b124de3ef859acfc03641f97ac630f652445..d32185b6bf48f7b6d49f355c0653004310bde533 100644
--- a/tensorflow/core/kernels/cwise_ops.h
+++ b/tensorflow/core/kernels/cwise_ops.h
@@ -49,7 +49,11 @@ template <typename T>
 struct scalar_asinh_op {
   EIGEN_EMPTY_STRUCT_CTOR(scalar_asinh_op)
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T operator()(const T& a) const {
+#if EIGEN_HAS_CXX11_MATH
+    return numext::asinh(a);
+#else
     return std::asinh(a);
+#endif  // EIGEN_HAS_CXX11_MATH
   }
 };
 template <typename T>
@@ -61,7 +65,11 @@ template <typename T>
 struct scalar_acosh_op {
   EIGEN_EMPTY_STRUCT_CTOR(scalar_acosh_op)
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T operator()(const T& a) const {
+#if EIGEN_HAS_CXX11_MATH
+    return numext::acosh(a);
+#else
     return std::acosh(a);
+#endif  // EIGEN_HAS_CXX11_MATH
   }
 };
 template <typename T>
@@ -73,7 +81,11 @@ template <typename T>
 struct scalar_atanh_op {
   EIGEN_EMPTY_STRUCT_CTOR(scalar_atanh_op)
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T operator()(const T& a) const {
+#if EIGEN_HAS_CXX11_MATH
+    return numext::atanh(a);
+#else
     return std::atanh(a);
+#endif  // EIGEN_HAS_CXX11_MATH
   }
 };
 template <typename T>
diff --git a/tensorflow/core/kernels/dataset.h b/tensorflow/core/kernels/dataset.h
index 44f7c2aca31c9825ba4d9f08e45f1930f96a464b..4a42ac80c37d322c9b2739ab4aad3c8a399ff19c 100644
--- a/tensorflow/core/kernels/dataset.h
+++ b/tensorflow/core/kernels/dataset.h
@@ -242,29 +242,18 @@ class GraphDefBuilderWrapper {
 // TODO(mrry): We will probably need to support more of
 // OpKernelContext here. For example, should allocation be handled by
 // the IteratorContext?
-// TODO(mrry): We will need to fabricate step IDs for calls to ops
-// that are not nested within a particular step.
 // TODO(mrry): We're making some daring assumptions about the lifetime
-// of the FunctionLibraryRuntime and runner passed in here. Once
-// created, a FunctionLibraryRuntime should stay alive for the
-// remainder of a session, so we copy the pointer. A runner will be
-// deleted when the original step ends, but all existing runners only
-// close over session-lifetime (or longer-lived) state, so we can make
-// a copy of the function. There's nothing in the definition of either
-// class to guarantee that what we are doing is safe. We should
-// formalize the properties here.
+// of the runner passed in here. A runner will be deleted when the original
+// step ends, but all existing runners only close over session-lifetime (or
+// longer-lived) state, so we can make a copy of the function. There's nothing
+// in the definition of the API from which we took the runner to guarantee that
+// what we are doing is safe. We should formalize the properties here.
 class IteratorContext {
  public:
   struct Params {
     // Interface to operating system functionality.
     Env* env;
 
-    // The step being executed.
-    int64 step_id = 0;
-
-    // Shared resources accessible by this iterator invocation.
-    ResourceMgr* resource_manager = nullptr;
-
     // Function call support.
     std::function<void(std::function<void()>)> runner = nullptr;
   };
@@ -273,14 +262,10 @@ class IteratorContext {
 
   Env* env() const { return params_.env; }
 
-  int64 step_id() const { return params_.step_id; }
-
   std::function<void(std::function<void()>)>* runner() {
     return &params_.runner;
   }
 
-  ResourceMgr* resource_manager() const { return params_.resource_manager; }
-
  private:
   Params params_;
 };
diff --git a/tensorflow/core/kernels/fake_quant_ops_functor.h b/tensorflow/core/kernels/fake_quant_ops_functor.h
index a6cd0078eed86ba2e6d5a50324e351a95daf1856..b41b22d634ddb3cdcec691e2f15f97fd2f1292c6 100644
--- a/tensorflow/core/kernels/fake_quant_ops_functor.h
+++ b/tensorflow/core/kernels/fake_quant_ops_functor.h
@@ -128,8 +128,15 @@ struct FakeQuantWithMinMaxVarsFunctor {
                   ConstScalar<float> min, ConstScalar<float> max,
                   const int quant_min, const int quant_max,
                   Flat<float> outputs) {
+    const float min_val = min();
+    const float max_val = max();
+    // If min and max are both zero, we should just return zero.
+    if (min_val == 0.0f && max_val == 0.0f) {
+      outputs.setZero();
+      return;
+    }
     float nudged_min, nudged_max, nudged_scale;
-    Nudge(min(), max(), quant_min, quant_max, &nudged_min, &nudged_max,
+    Nudge(min_val, max_val, quant_min, quant_max, &nudged_min, &nudged_max,
           &nudged_scale);
     const auto nudged_scale_repl = inputs.constant(nudged_scale);
 
@@ -151,8 +158,17 @@ struct FakeQuantWithMinMaxVarsGradientFunctor {
                   const int quant_max, Flat<float> backprops_wrt_input,
                   Scalar<float> backprop_wrt_min,
                   Scalar<float> backprop_wrt_max) {
+    const float min_val = min();
+    const float max_val = max();
+    // If min and max are both zero, we propagate everything to inputs.
+    if (min_val == 0.0f && max_val == 0.0f) {
+      backprops_wrt_input.device(d) = gradients;
+      backprop_wrt_min.setZero();
+      backprop_wrt_max.setZero();
+      return;
+    }
     float nudged_min, nudged_max, nudged_scale;
-    Nudge(min(), max(), quant_min, quant_max, &nudged_min, &nudged_max,
+    Nudge(min_val, max_val, quant_min, quant_max, &nudged_min, &nudged_max,
           &nudged_scale);
 
     const auto between_min_max =
@@ -185,8 +201,15 @@ struct FakeQuantWithMinMaxVarsPerChannelFunctor {
                   ConstVec<float> min, ConstVec<float> max, const int quant_min,
                   const int quant_max, TTypes<float>::Matrix outputs) {
     for (Index i = 0; i < min.size(); ++i) {
+      const float min_val = min(i);
+      const float max_val = max(i);
+      // If min and max are both zero, we should just return zero.
+      if (min_val == 0.0f && max_val == 0.0f) {
+        outputs.chip<1>(i).setZero();
+        continue;
+      }
       float nudged_min, nudged_max, nudged_scale;
-      Nudge(min(i), max(i), quant_min, quant_max, &nudged_min, &nudged_max,
+      Nudge(min_val, max_val, quant_min, quant_max, &nudged_min, &nudged_max,
             &nudged_scale);
       const auto clamped =
           inputs.chip<1>(i).cwiseMin(nudged_max).cwiseMax(nudged_min);
@@ -212,11 +235,20 @@ struct FakeQuantWithMinMaxVarsPerChannelGradientFunctor {
                   TTypes<float>::Matrix backprops_wrt_input,
                   Vec<float> backprop_wrt_min, Vec<float> backprop_wrt_max) {
     for (Index i = 0; i < min.size(); ++i) {
-      float nudged_min, nudged_max, nudged_scale;
-      Nudge(min(i), max(i), quant_min, quant_max, &nudged_min, &nudged_max,
-            &nudged_scale);
+      const float min_val = min(i);
+      const float max_val = max(i);
       const auto gradients_chip = gradients.chip<1>(i);
       const auto inputs_chip = inputs.chip<1>(i);
+      // If min and max are both zero, we propagate everything to inputs.
+      if (min_val == 0.0f && max_val == 0.0f) {
+        backprops_wrt_input.chip<1>(i).device(d) = gradients_chip;
+        backprop_wrt_min.chip<0>(i).setZero();
+        backprop_wrt_max.chip<0>(i).setZero();
+        continue;
+      }
+      float nudged_min, nudged_max, nudged_scale;
+      Nudge(min_val, max_val, quant_min, quant_max, &nudged_min, &nudged_max,
+            &nudged_scale);
 
       const auto between_min_max =
           (inputs_chip >= nudged_min && inputs_chip <= nudged_max)
diff --git a/tensorflow/core/kernels/fake_quant_ops_test.cc b/tensorflow/core/kernels/fake_quant_ops_test.cc
index 8dd3f055bc7d6fc317ca80ba4e0418dcd5e05a98..5953db14768fd4e8d6c8537a2bea91c2ca211b17 100644
--- a/tensorflow/core/kernels/fake_quant_ops_test.cc
+++ b/tensorflow/core/kernels/fake_quant_ops_test.cc
@@ -476,6 +476,12 @@ TEST_F(QuantOpsTest, WithArgsGradient_4Bits_NarrowRange) {
   ExpectClose(expected, *output);
 }
 
+TEST_F(QuantOpsTest, WithVars_ZeroMinAndMax) {
+  RunTestFakeQuantWithMinMaxVars(8, false, 0.0f, 0.0f, TensorShape({2, 3}),
+                                 {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f},
+                                 {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f});
+}
+
 TEST_F(QuantOpsTest, WithVarsNoNudging_RegularRange) {
   // Original quantization range: [-10 + 0 / 4, -10 + 255 / 4], scale: 1/4.
   // Original zero point: 40, no nudging necessary.
@@ -637,6 +643,47 @@ TEST_F(QuantOpsTest, WithVarsNudgedZero15_4Bits_NarrowRange) {
                                  {-7.0f, -7.0f, -7.0f, -6.5f, 0.0f, 0.0f});
 }
 
+TEST_F(QuantOpsTest, WithVarsGradient_ZeroMinAndMax) {
+  TF_EXPECT_OK(NodeDefBuilder("op", "FakeQuantWithMinMaxVarsGradient")
+                   .Attr("narrow_range", false)
+                   .Input(FakeInput(DT_FLOAT))  // gradients
+                   .Input(FakeInput(DT_FLOAT))  // inputs
+                   .Input(FakeInput(DT_FLOAT))  // min
+                   .Input(FakeInput(DT_FLOAT))  // max
+                   .Finalize(node_def()));
+  TF_EXPECT_OK(InitOp());
+  // Upstream gradients.
+  AddRandomInput(TensorShape({2, 3}));
+  // Downstream inputs.
+  AddInputFromArray<float>(TensorShape({2, 3}),
+                           {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f});
+  // Min.
+  AddInputFromArray<float>(TensorShape({}), {0.0f});
+  // Max.
+  AddInputFromArray<float>(TensorShape({}), {0.0f});
+
+  // Tested code.
+  TF_ASSERT_OK(RunOpKernel());
+
+  Tensor* output_bprop_wrt_input = GetOutput(0);
+  Tensor expected_bprop_wrt_input(allocator(), DT_FLOAT, TensorShape({2, 3}));
+  auto in_flat = GetInput(0).flat<float>();
+  FillValues<float>(
+      &expected_bprop_wrt_input,
+      {in_flat(0), in_flat(1), in_flat(2), in_flat(3), in_flat(4), in_flat(5)});
+  ExpectClose(expected_bprop_wrt_input, *output_bprop_wrt_input);
+
+  Tensor* output_bprop_wrt_min = GetOutput(1);
+  Tensor expected_bprop_wrt_min(allocator(), DT_FLOAT, TensorShape({}));
+  expected_bprop_wrt_min.flat<float>()(0) = 0.0f;
+  ExpectClose(expected_bprop_wrt_min, *output_bprop_wrt_min);
+
+  Tensor* output_bprop_wrt_max = GetOutput(2);
+  Tensor expected_bprop_wrt_max(allocator(), DT_FLOAT, TensorShape({}));
+  expected_bprop_wrt_max.flat<float>()(0) = 0.0f;
+  ExpectClose(expected_bprop_wrt_max, *output_bprop_wrt_max);
+}
+
 TEST_F(QuantOpsTest, WithVarsGradient_RegularRange) {
   // Original quantization range: [-0.5 / 4 + 0 / 4, -0.5 / 4 + 255 / 4].
   // Scale: 1/4,  original zero point: 0.5, nudged to 1.
@@ -815,6 +862,13 @@ TEST_F(QuantOpsTest, WithVarsGradient_4Bits_NarrowRange) {
   ExpectClose(expected_bprop_wrt_max, *output_bprop_wrt_max);
 }
 
+TEST_F(QuantOpsTest, WithVarsPerChannel_ZeroMinAndMax) {
+  RunTestFakeQuantWithMinMaxVarsPerChannel(
+      8, false, TensorShape({4}), {0.0f, 0.0f, 0.0f, 0.0f},
+      {0.0f, 0.0f, 0.0f, 0.0f}, TensorShape({4}), {0.0f, 0.0f, 0.0f, 0.0f},
+      {0.0f, 0.0f, 0.0f, 0.0f});
+}
+
 TEST_F(QuantOpsTest, WithVarsPerChannelDim1NudgedDown_RegularRange) {
   // Original quantization ranges: [-0.4 / 4 + 0 / 4, -0.4 / 4 + 255 / 4].
   // Scale: 1/4,  original zero point: 0.4, nudged to 0.
@@ -1166,6 +1220,45 @@ TEST_F(QuantOpsTest, WithVarsPerChannelDim4NudgedUp_4Bits_NarrowRange) {
   // clang-format on
 }
 
+TEST_F(QuantOpsTest, WithVarsPerChannelDim1GradientNudgedDown_ZeroMinAndMax) {
+  TF_EXPECT_OK(NodeDefBuilder("op", "FakeQuantWithMinMaxVarsPerChannelGradient")
+                   .Attr("narrow_range", false)
+                   .Input(FakeInput(DT_FLOAT))  // gradients
+                   .Input(FakeInput(DT_FLOAT))  // inputs
+                   .Input(FakeInput(DT_FLOAT))  // min
+                   .Input(FakeInput(DT_FLOAT))  // max
+                   .Finalize(node_def()));
+  TF_EXPECT_OK(InitOp());
+  // Upstream gradients.
+  AddRandomInput(TensorShape({4}));
+  // Downstream inputs.
+  AddInputFromArray<float>(TensorShape({4}), {0.0, 0.0, 0.0, 0.0f});
+  // Min.
+  AddInputFromArray<float>(TensorShape({4}), {0.0, 0.0, 0.0, 0.0f});
+  // Max.
+  AddInputFromArray<float>(TensorShape({4}), {0.0, 0.0, 0.0, 0.0f});
+
+  // Tested code.
+  TF_ASSERT_OK(RunOpKernel());
+
+  Tensor* output_bprop_wrt_input = GetOutput(0);
+  Tensor expected_bprop_wrt_input(allocator(), DT_FLOAT, TensorShape({4}));
+  auto grad_flat = GetInput(0).flat<float>();
+  FillValues<float>(&expected_bprop_wrt_input,
+                    {grad_flat(0), grad_flat(1), grad_flat(2), grad_flat(3)});
+  ExpectClose(expected_bprop_wrt_input, *output_bprop_wrt_input);
+
+  Tensor* output_bprop_wrt_min = GetOutput(1);
+  Tensor expected_bprop_wrt_min(allocator(), DT_FLOAT, TensorShape({4}));
+  FillValues<float>(&expected_bprop_wrt_min, {0.0f, 0.0f, 0.0f, 0.0f});
+  ExpectClose(expected_bprop_wrt_min, *output_bprop_wrt_min);
+
+  Tensor* output_bprop_wrt_max = GetOutput(2);
+  Tensor expected_bprop_wrt_max(allocator(), DT_FLOAT, TensorShape({4}));
+  FillValues<float>(&expected_bprop_wrt_max, {0.0f, 0.0f, 0.0f, 0.0f});
+  ExpectClose(expected_bprop_wrt_max, *output_bprop_wrt_max);
+}
+
 TEST_F(QuantOpsTest, WithVarsPerChannelDim1GradientNudgedDown_RegularRange) {
   // Original quantization ranges: [-0.4 / 4 + 0 / 4, -0.4 / 4 + 255 / 4].
   // Scale: 1/4,  original zero point: 0.4, nudged to 0.
diff --git a/tensorflow/core/kernels/generate_vocab_remapping_op.cc b/tensorflow/core/kernels/generate_vocab_remapping_op.cc
index 247c1f24577212c2b7cc5bb44ba9a883636389ea..2b97677e3859002bee07f073b1de1a19c806c6ae 100644
--- a/tensorflow/core/kernels/generate_vocab_remapping_op.cc
+++ b/tensorflow/core/kernels/generate_vocab_remapping_op.cc
@@ -41,6 +41,8 @@ class GenerateVocabRemappingOp : public OpKernel {
     OP_REQUIRES_OK(context,
                    context->GetAttr("new_vocab_offset", &new_vocab_offset_));
     OP_REQUIRES_OK(context, context->GetAttr("num_new_vocab", &num_new_vocab_));
+    OP_REQUIRES_OK(context,
+                   context->GetAttr("old_vocab_size", &old_vocab_size_));
   }
 
   void Compute(OpKernelContext* context) override {
@@ -92,16 +94,14 @@ class GenerateVocabRemappingOp : public OpKernel {
     lookup::HashTable<string, int64>* old_vocab_table =
         new lookup::HashTable<string, int64>(context, this);
     core::ScopedUnref unref_old(old_vocab_table);
-    // Note: we pass -1 (unknown) for vocab_size, which is supposed to be the
-    // total elements in file.  This is different from num_new_vocab_, which
-    // accounts for partitioning.
-    OP_REQUIRES_OK(context, lookup::InitializeTableFromTextFile(
-                                old_vocab_filename,
-                                -1,  // vocab_size
-                                kUnusedLookupDelim,
-                                -2,  // key_index, use the whole line/token.
-                                -1,  // value_index, use the line number.
-                                context->env(), old_vocab_table));
+    // Note: If old_vocab_size_ is -1 (unknown), we retrieve all elements in
+    // file (see TextFileLineIterator).
+    OP_REQUIRES_OK(context,
+                   lookup::InitializeTableFromTextFile(
+                       old_vocab_filename, old_vocab_size_, kUnusedLookupDelim,
+                       -2,  // key_index, use the whole line/token.
+                       -1,  // value_index, use the line number.
+                       context->env(), old_vocab_table));
 
     // Fill out new_ids = [new_vocab_offset, new_vocab_offset + 1, ...,
     //                     new_vocab_offset + num_new_vocab_]
@@ -165,6 +165,7 @@ class GenerateVocabRemappingOp : public OpKernel {
  private:
   int new_vocab_offset_;
   int num_new_vocab_;
+  int old_vocab_size_;
 };
 
 REGISTER_KERNEL_BUILDER(Name("GenerateVocabRemapping").Device(DEVICE_CPU),
diff --git a/tensorflow/core/kernels/iterator_ops.cc b/tensorflow/core/kernels/iterator_ops.cc
index ad9355d3defbb35ed9fda21edd07a15b32f46cc5..ae77ae6433879738ae1fb7facd713d676e41f3f9 100644
--- a/tensorflow/core/kernels/iterator_ops.cc
+++ b/tensorflow/core/kernels/iterator_ops.cc
@@ -427,8 +427,6 @@ class ToSingleElementOp : public OpKernel {
 
     IteratorContext::Params params;
     params.env = ctx->env();
-    params.step_id = ctx->step_id();
-    params.resource_manager = ctx->resource_manager();
     params.runner = *(ctx->runner());
     IteratorContext iter_ctx(std::move(params));
 
@@ -664,8 +662,6 @@ class IteratorGetNextOp : public AsyncOpKernel {
 
       IteratorContext::Params params;
       params.env = ctx->env();
-      params.step_id = ctx->step_id();
-      params.resource_manager = ctx->resource_manager();
       params.runner = *(ctx->runner());
       IteratorContext iter_ctx(std::move(params));
 
@@ -787,7 +783,7 @@ class SerializeIteratorOp : public OpKernel {
     IteratorResource* iterator_resource;
     OP_REQUIRES_OK(
         ctx, LookupResource(ctx, HandleFromInput(ctx, 0), &iterator_resource));
-    iterator_resource->Unref();
+    core::ScopedUnref unref_iterator(iterator_resource);
     Tensor* variant_t;
     OP_REQUIRES_OK(ctx, ctx->allocate_output(0, TensorShape({}), &variant_t));
     IteratorStateVariant v;
diff --git a/tensorflow/core/kernels/matrix_exponential_op.cc b/tensorflow/core/kernels/matrix_exponential_op.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4cc3f32f7e4a727fa2d9ec3c21a3750111f46392
--- /dev/null
+++ b/tensorflow/core/kernels/matrix_exponential_op.cc
@@ -0,0 +1,59 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// See docs in ../ops/linalg_ops.cc.
+
+#include "third_party/eigen3/Eigen/Core"
+#include "third_party/eigen3/unsupported/Eigen/MatrixFunctions"
+#include "tensorflow/core/framework/kernel_def_builder.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/kernels/linalg_ops_common.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/types.h"
+
+
+namespace tensorflow {
+
+template <class Scalar>
+class MatrixExponentialOp : public LinearAlgebraOp<Scalar> {
+ public:
+  INHERIT_LINALG_TYPEDEFS(Scalar);
+
+  explicit MatrixExponentialOp(OpKernelConstruction* context) : Base(context) {}
+
+  void ComputeMatrix(OpKernelContext* context, const ConstMatrixMaps& inputs,
+                     MatrixMaps* outputs) final {
+    const ConstMatrixMap& input = inputs[0];
+    if (input.rows() == 0) return;
+    using Matrix = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
+    Matrix tmp = input;
+    outputs->at(0) = tmp.exp();
+  }
+
+ private:
+  TF_DISALLOW_COPY_AND_ASSIGN(MatrixExponentialOp);
+};
+
+REGISTER_LINALG_OP("MatrixExponential", (MatrixExponentialOp<float>), float);
+REGISTER_LINALG_OP("MatrixExponential", (MatrixExponentialOp<double>), double);
+REGISTER_LINALG_OP("MatrixExponential",
+                   (MatrixExponentialOp<complex64>), complex64);
+REGISTER_LINALG_OP("MatrixExponential",
+                   (MatrixExponentialOp<complex128>), complex128);
+
+}  // namespace tensorflow
diff --git a/tensorflow/core/kernels/prefetch_dataset_op.cc b/tensorflow/core/kernels/prefetch_dataset_op.cc
index a7aac508eb3f76a588f9fc39b761e33222a37041..80592aa353a4dadf38a2a303b6ad0108c65ab976 100644
--- a/tensorflow/core/kernels/prefetch_dataset_op.cc
+++ b/tensorflow/core/kernels/prefetch_dataset_op.cc
@@ -37,30 +37,14 @@ class PrefetchDatasetOp : public UnaryDatasetOpKernel {
     OP_REQUIRES_OK(
         ctx, ParseScalarArgument<int64>(ctx, "buffer_size", &buffer_size));
 
-    // TODO(mrry): It seems unnatural to capture the params from *this
-    // kernel's* OpKernelContext, although the captured values should
-    // be the same for any kernel in the same session. Consider adding
-    // an IteratorContext* argument to Dataset::MakeIterator(), and
-    // threading the context information through that
-    // way. Alternatively, provide a session-scoped context that will
-    // provide this information to all users in the same session (and
-    // that will have the appropriate lifetime).
-    IteratorContext::Params params;
-    params.env = ctx->env();
-    params.resource_manager = ctx->resource_manager();
-    params.runner = *(ctx->runner());
-
-    *output = new Dataset(input, buffer_size, std::move(params));
+    *output = new Dataset(input, buffer_size);
   }
 
  private:
   class Dataset : public DatasetBase {
    public:
-    Dataset(const DatasetBase* input, int64 buffer_size,
-            IteratorContext::Params ctx_params)
-        : input_(input),
-          buffer_size_(buffer_size),
-          ctx_params_(std::move(ctx_params)) {
+    Dataset(const DatasetBase* input, int64 buffer_size)
+        : input_(input), buffer_size_(buffer_size) {
       input_->Ref();
     }
 
@@ -218,7 +202,6 @@ class PrefetchDatasetOp : public UnaryDatasetOpKernel {
 
     const DatasetBase* const input_;
     const int64 buffer_size_;
-    const IteratorContext::Params ctx_params_;
   };
 };
 
diff --git a/tensorflow/core/kernels/segment_reduction_ops.cc b/tensorflow/core/kernels/segment_reduction_ops.cc
index 4302a68a185e66ee3a8f10e92e58d93df4979800..2334e50f1dcb08e9662615e83d721f8b08568102 100644
--- a/tensorflow/core/kernels/segment_reduction_ops.cc
+++ b/tensorflow/core/kernels/segment_reduction_ops.cc
@@ -376,6 +376,9 @@ struct UnsortedSegmentSumFunctor<CPUDevice, T, Index>
     auto data_flat = typename TTypes<T, 2>::ConstTensor(data, N, data_size / N);
     for (int64 i = 0; i < N; ++i) {
       Index j = internal::SubtleMustCopy(segment_ids(i));
+      if (j < 0) {
+        continue;
+      }
       OP_REQUIRES(ctx, FastBoundsCheck(j, output_rows),
                   errors::InvalidArgument(
                       "segment_ids", SliceDebugString(segment_ids_shape, i),
diff --git a/tensorflow/core/kernels/segment_reduction_ops.h b/tensorflow/core/kernels/segment_reduction_ops.h
index 412c1d601d3116b7de5ee09afe1e4f1d0253b349..b10bea72ba89e7089e0668389995c629644b534d 100644
--- a/tensorflow/core/kernels/segment_reduction_ops.h
+++ b/tensorflow/core/kernels/segment_reduction_ops.h
@@ -30,14 +30,14 @@ namespace functor {
 #ifdef GOOGLE_CUDA
 typedef Eigen::GpuDevice GPUDevice;
 // Functor for SegmentSumGPUOp.
-// 'output_rows': the number of output segments (unique segment ids in
+// output_rows: the number of output segments (unique segment ids in
 //                'segment_ids').
-// 'segment_ids_shape': shape of 'segment_ids' tensor.
-// 'segment_ids': unsorted map from input to output segment ids at which to
+// segment_ids_shape: shape of 'segment_ids' tensor.
+// segment_ids: unsorted map from input to output segment ids at which to
 //                perform segment sum operation.
-// 'data_size': size of input data tensor.
-// 'data': input data tensor.
-// 'output': output reshaped to {output_rows, output.size/output_rows}
+// data_size: size of input data tensor.
+// data: input data tensor.
+// output: output reshaped to {output_rows, output.size/output_rows}
 template <typename T, typename Index>
 struct SegmentSumFunctor {
   void operator()(OpKernelContext* ctx, const GPUDevice& d,
@@ -61,14 +61,14 @@ struct UnsortedSegmentBaseFunctor{
 };
 
 // Functor for UnsortedSegmentSumOp.
-// 'output_rows': the number of output segments (unique segment ids in
+// output_rows: the number of output segments (unique segment ids in
 //                'segment_ids').
-// 'segment_ids_shape': shape of 'segment_ids' tensor.
-// 'segment_ids': unsorted map from input to output segment ids at which to
+// segment_ids_shape: shape of 'segment_ids' tensor.
+// segment_ids: unsorted map from input to output segment ids at which to
 //                perform segment sum operation.
-// 'data_size': size of input data tensor.
-// 'data': input data tensor.
-// 'output': output reshaped to {output_rows, output.size/output_rows}
+// data_size: size of input data tensor.
+// data: input data tensor.
+// output: output reshaped to {output_rows, output.size/output_rows}
 template <typename Device, typename T, typename Index>
 struct UnsortedSegmentSumFunctor: public UnsortedSegmentBaseFunctor<Device, T, Index> {
   void operator()(OpKernelContext* ctx, const Device& d,
@@ -79,14 +79,14 @@ struct UnsortedSegmentSumFunctor: public UnsortedSegmentBaseFunctor<Device, T, I
 };
 
 // Functor for UnsortedSegmentMaxOp.
-// 'output_rows': the number of output segments (unique segment ids in
+// output_rows: the number of output segments (unique segment ids in
 //                'segment_ids').
-// 'segment_ids_shape': shape of 'segment_ids' tensor.
-// 'segment_ids': unsorted map from input to output segment ids at which to
+// segment_ids_shape: shape of 'segment_ids' tensor.
+// segment_ids: unsorted map from input to output segment ids at which to
 //                perform segment sum operation.
-// 'data_size': size of input data tensor.
-// 'data': input data tensor.
-// 'output': output reshaped to {output_rows, output.size/output_rows}
+// data_size: size of input data tensor.
+// data: input data tensor.
+// output: output reshaped to {output_rows, output.size/output_rows}
 template <typename Device, typename T, typename Index>
 struct UnsortedSegmentMaxFunctor: public UnsortedSegmentBaseFunctor<Device, T, Index> {
   void operator()(OpKernelContext* ctx, const Device& d,
diff --git a/tensorflow/core/kernels/tensor_array.h b/tensorflow/core/kernels/tensor_array.h
index 6882a8a0e5fc49809468d73a1f828403092a96fb..2a41d4c419a08b05e1cdbb0d5db1dcfea27b3836 100644
--- a/tensorflow/core/kernels/tensor_array.h
+++ b/tensorflow/core/kernels/tensor_array.h
@@ -537,30 +537,33 @@ Status TensorArray::LockedRead(OpKernelContext* ctx, const int32 index,
                                    " but array size is: ", tensors_.size());
   }
   size_t index_t = static_cast<size_t>(index);
-  if (is_grad_ && (index_t >= tensors_.size() || !tensors_[index].written)) {
+  if ((is_grad_ && (index_t >= tensors_.size() || !tensors_[index].written)) ||
+      (!is_grad_ && (index_t < tensors_.size() && !tensors_[index].written))) {
     // Special case returning zeros if this is a gradient read that happens
     // after a stop_gradients call with dynamic forward TensorArrays.
     // There is sometimes a race condition where the gradient is not
     // written due to stop_gradients, but is later read.
     TensorShape element_shape;
-    if (index_t < tensors_.size() && tensors_[index].shape.dims() > 0) {
+    if (is_grad_ && index_t < tensors_.size() &&
+        tensors_[index].shape.dims() > 0) {
+      // A gradient TensorArray has more specific gradient information
+      // available for each entry.  A forward TensorArray must rely on
+      // the global element_shape_ to fill in zeros on read.
       element_shape = tensors_[index].shape;
     } else if (!element_shape_.IsFullyDefined()) {
       return errors::InvalidArgument(
           "TensorArray ", handle_.vec<string>()(1),
-          ": Could not read from gradient TensorArray index ", index,
+          ": Could not read from TensorArray index ", index,
           ".  Furthermore, the element shape is not fully defined: ",
           element_shape_.DebugString(),
-          ".  "
-          "It is likely you are working with a resizeable TensorArray and "
-          "stop_gradients "
-          "is not allowing the gradients to be written.  If you set the full "
-          "element_shape "
-          "property on the forward TensorArray, the proper all-zeros tensor "
-          "will be "
-          "returned instead of incurring this error.");
+          ".  It is possible you are working with a resizeable TensorArray and "
+          "stop_gradients is not allowing the gradients to be written.  If you "
+          "set the full "
+          "element_shape property on the forward TensorArray, the proper "
+          "all-zeros tensor "
+          "will be returned instead of incurring this error.");
     } else {
-      DCHECK(element_shape_.AsTensorShape(&element_shape));
+      element_shape_.AsTensorShape(&element_shape);  // Always succeeds.
     }
     if (index_t >= tensors_.size()) {
       // Fill in tensors_ up to index to have known shape.
@@ -578,13 +581,6 @@ Status TensorArray::LockedRead(OpKernelContext* ctx, const int32 index,
 
   TensorAndState& t = tensors_[index];
 
-  if (!t.written) {
-    return errors::InvalidArgument("TensorArray ", handle_.vec<string>()(1),
-                                   ": Could not read from TensorArray index ",
-                                   index,
-                                   " because it has not yet been written to.");
-  }
-
   if (t.cleared) {
     return errors::InvalidArgument("TensorArray ", handle_.vec<string>()(1),
                                    ": Could not read index ", index,
diff --git a/tensorflow/core/ops/checkpoint_ops.cc b/tensorflow/core/ops/checkpoint_ops.cc
index b49d7b4d40f6a79e966c0ab8f2ef8cedb004b27c..08b00c8255c8e44cea9a2e0d4c97378ecc3bb998 100644
--- a/tensorflow/core/ops/checkpoint_ops.cc
+++ b/tensorflow/core/ops/checkpoint_ops.cc
@@ -22,6 +22,7 @@ REGISTER_OP("GenerateVocabRemapping")
     .Input("old_vocab_file: string")
     .Attr("new_vocab_offset: int >= 0")
     .Attr("num_new_vocab: int >= 0")
+    .Attr("old_vocab_size: int >= -1 = -1")
     .Output("remapping: int64")
     .Output("num_present: int32")
     .SetShapeFn([](shape_inference::InferenceContext* c) {
@@ -43,7 +44,11 @@ Given a path to new and old vocabulary files, returns a remapping Tensor of
 length `num_new_vocab`, where `remapping[i]` contains the row number in the old
 vocabulary that corresponds to row `i` in the new vocabulary (starting at line
 `new_vocab_offset` and up to `num_new_vocab` entities), or `-1` if entry `i`
-in the new vocabulary is not in the old vocabulary.  `num_vocab_offset` enables
+in the new vocabulary is not in the old vocabulary.  The old vocabulary is
+constrained to the first `old_vocab_size` entries if `old_vocab_size` is not the
+default value of -1.
+
+`num_vocab_offset` enables
 use in the partitioned variable case, and should generally be set through
 examining partitioning info.  The format of the files should be a text file,
 with each line containing a single entity within the vocabulary.
@@ -69,6 +74,8 @@ new_vocab_file: Path to the new vocab file.
 old_vocab_file: Path to the old vocab file.
 new_vocab_offset: How many entries into the new vocab file to start reading.
 num_new_vocab: Number of entries in the new vocab file to remap.
+old_vocab_size: Number of entries in the old vocab file to consider.  If -1,
+  use the entire old vocabulary.
 remapping: A Tensor of length num_new_vocab where the element at index i
   is equal to the old ID that maps to the new ID i.  This element is -1 for any
   new ID that is not found in the old vocabulary.
diff --git a/tensorflow/core/ops/compat/ops_history.v1.pbtxt b/tensorflow/core/ops/compat/ops_history.v1.pbtxt
index 382812be185199b9c1823c1df3fe25a2fe923402..8b8251f84beaf398a9936208e2e1d05ec6dbd525 100644
--- a/tensorflow/core/ops/compat/ops_history.v1.pbtxt
+++ b/tensorflow/core/ops/compat/ops_history.v1.pbtxt
@@ -8270,29 +8270,6 @@ op {
     }
   }
 }
-op {
-  name: "DatasetToSingleElement"
-  input_arg {
-    name: "dataset"
-    type: DT_VARIANT
-  }
-  output_arg {
-    name: "components"
-    type_list_attr: "output_types"
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-}
 op {
   name: "DebugGradientIdentity"
   input_arg {
@@ -9271,69 +9248,6 @@ op {
     }
   }
 }
-op {
-  name: "DenseToSparseBatchDataset"
-  input_arg {
-    name: "input_dataset"
-    type: DT_VARIANT
-  }
-  input_arg {
-    name: "batch_size"
-    type: DT_INT64
-  }
-  input_arg {
-    name: "row_shape"
-    type: DT_INT64
-  }
-  output_arg {
-    name: "handle"
-    type: DT_VARIANT
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-  is_stateful: true
-}
-op {
-  name: "DenseToSparseBatchDataset"
-  input_arg {
-    name: "input_dataset"
-    type: DT_VARIANT
-  }
-  input_arg {
-    name: "batch_size"
-    type: DT_INT64
-  }
-  input_arg {
-    name: "row_shape"
-    type: DT_INT64
-  }
-  output_arg {
-    name: "handle"
-    type: DT_VARIANT
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-}
 op {
   name: "DenseToSparseSetOperation"
   input_arg {
@@ -9827,18 +9741,6 @@ op {
     }
   }
 }
-op {
-  name: "DeserializeIterator"
-  input_arg {
-    name: "resource_handle"
-    type: DT_RESOURCE
-  }
-  input_arg {
-    name: "serialized"
-    type: DT_VARIANT
-  }
-  is_stateful: true
-}
 op {
   name: "DeserializeManySparse"
   input_arg {
@@ -13343,6 +13245,44 @@ op {
     has_minimum: true
   }
 }
+op {
+  name: "GenerateVocabRemapping"
+  input_arg {
+    name: "new_vocab_file"
+    type: DT_STRING
+  }
+  input_arg {
+    name: "old_vocab_file"
+    type: DT_STRING
+  }
+  output_arg {
+    name: "remapping"
+    type: DT_INT64
+  }
+  output_arg {
+    name: "num_present"
+    type: DT_INT32
+  }
+  attr {
+    name: "new_vocab_offset"
+    type: "int"
+    has_minimum: true
+  }
+  attr {
+    name: "num_new_vocab"
+    type: "int"
+    has_minimum: true
+  }
+  attr {
+    name: "old_vocab_size"
+    type: "int"
+    default_value {
+      i: -1
+    }
+    has_minimum: true
+    minimum: -1
+  }
+}
 op {
   name: "GetSessionHandle"
   input_arg {
@@ -13554,131 +13494,6 @@ op {
     }
   }
 }
-op {
-  name: "GroupByWindowDataset"
-  input_arg {
-    name: "input_dataset"
-    type: DT_VARIANT
-  }
-  input_arg {
-    name: "key_func_other_arguments"
-    type_list_attr: "Tkey_func_other_arguments"
-  }
-  input_arg {
-    name: "reduce_func_other_arguments"
-    type_list_attr: "Treduce_func_other_arguments"
-  }
-  input_arg {
-    name: "window_size_func_other_arguments"
-    type_list_attr: "Twindow_size_func_other_arguments"
-  }
-  output_arg {
-    name: "handle"
-    type: DT_VARIANT
-  }
-  attr {
-    name: "key_func"
-    type: "func"
-  }
-  attr {
-    name: "reduce_func"
-    type: "func"
-  }
-  attr {
-    name: "window_size_func"
-    type: "func"
-  }
-  attr {
-    name: "Tkey_func_other_arguments"
-    type: "list(type)"
-    has_minimum: true
-  }
-  attr {
-    name: "Treduce_func_other_arguments"
-    type: "list(type)"
-    has_minimum: true
-  }
-  attr {
-    name: "Twindow_size_func_other_arguments"
-    type: "list(type)"
-    has_minimum: true
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-  is_stateful: true
-}
-op {
-  name: "GroupByWindowDataset"
-  input_arg {
-    name: "input_dataset"
-    type: DT_VARIANT
-  }
-  input_arg {
-    name: "key_func_other_arguments"
-    type_list_attr: "Tkey_func_other_arguments"
-  }
-  input_arg {
-    name: "reduce_func_other_arguments"
-    type_list_attr: "Treduce_func_other_arguments"
-  }
-  input_arg {
-    name: "window_size_func_other_arguments"
-    type_list_attr: "Twindow_size_func_other_arguments"
-  }
-  output_arg {
-    name: "handle"
-    type: DT_VARIANT
-  }
-  attr {
-    name: "key_func"
-    type: "func"
-  }
-  attr {
-    name: "reduce_func"
-    type: "func"
-  }
-  attr {
-    name: "window_size_func"
-    type: "func"
-  }
-  attr {
-    name: "Tkey_func_other_arguments"
-    type: "list(type)"
-    has_minimum: true
-  }
-  attr {
-    name: "Treduce_func_other_arguments"
-    type: "list(type)"
-    has_minimum: true
-  }
-  attr {
-    name: "Twindow_size_func_other_arguments"
-    type: "list(type)"
-    has_minimum: true
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-}
 op {
   name: "HSVToRGB"
   input_arg {
@@ -14099,53 +13914,6 @@ op {
     }
   }
 }
-op {
-  name: "IgnoreErrorsDataset"
-  input_arg {
-    name: "input_dataset"
-    type: DT_VARIANT
-  }
-  output_arg {
-    name: "handle"
-    type: DT_VARIANT
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-  is_stateful: true
-}
-op {
-  name: "IgnoreErrorsDataset"
-  input_arg {
-    name: "input_dataset"
-    type: DT_VARIANT
-  }
-  output_arg {
-    name: "handle"
-    type: DT_VARIANT
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-}
 op {
   name: "Imag"
   input_arg {
@@ -16050,50 +15818,6 @@ op {
   }
   is_stateful: true
 }
-op {
-  name: "MapAndBatchDataset"
-  input_arg {
-    name: "input_dataset"
-    type: DT_VARIANT
-  }
-  input_arg {
-    name: "other_arguments"
-    type_list_attr: "Targuments"
-  }
-  input_arg {
-    name: "batch_size"
-    type: DT_INT64
-  }
-  input_arg {
-    name: "num_parallel_batches"
-    type: DT_INT64
-  }
-  output_arg {
-    name: "handle"
-    type: DT_VARIANT
-  }
-  attr {
-    name: "f"
-    type: "func"
-  }
-  attr {
-    name: "Targuments"
-    type: "list(type)"
-    has_minimum: true
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-}
 op {
   name: "MapClear"
   attr {
@@ -16652,6 +16376,29 @@ op {
     type: "type"
   }
 }
+op {
+  name: "MatrixExponential"
+  input_arg {
+    name: "input"
+    type_attr: "T"
+  }
+  output_arg {
+    name: "output"
+    type_attr: "T"
+  }
+  attr {
+    name: "T"
+    type: "type"
+    allowed_values {
+      list {
+        type: DT_DOUBLE
+        type: DT_FLOAT
+        type: DT_COMPLEX64
+        type: DT_COMPLEX128
+      }
+    }
+  }
+}
 op {
   name: "MatrixInverse"
   input_arg {
@@ -20809,54 +20556,6 @@ op {
     type: "type"
   }
 }
-op {
-  name: "ParallelInterleaveDataset"
-  input_arg {
-    name: "input_dataset"
-    type: DT_VARIANT
-  }
-  input_arg {
-    name: "other_arguments"
-    type_list_attr: "Targuments"
-  }
-  input_arg {
-    name: "cycle_length"
-    type: DT_INT64
-  }
-  input_arg {
-    name: "block_length"
-    type: DT_INT64
-  }
-  input_arg {
-    name: "sloppy"
-    type: DT_BOOL
-  }
-  output_arg {
-    name: "handle"
-    type: DT_VARIANT
-  }
-  attr {
-    name: "f"
-    type: "func"
-  }
-  attr {
-    name: "Targuments"
-    type: "list(type)"
-    has_minimum: true
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-}
 op {
   name: "ParallelMapDataset"
   input_arg {
@@ -30447,52 +30146,6 @@ op {
     }
   }
 }
-op {
-  name: "ScanDataset"
-  input_arg {
-    name: "input_dataset"
-    type: DT_VARIANT
-  }
-  input_arg {
-    name: "initial_state"
-    type_list_attr: "Tstate"
-  }
-  input_arg {
-    name: "other_arguments"
-    type_list_attr: "Targuments"
-  }
-  output_arg {
-    name: "handle"
-    type: DT_VARIANT
-  }
-  attr {
-    name: "f"
-    type: "func"
-  }
-  attr {
-    name: "Tstate"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "Targuments"
-    type: "list(type)"
-    has_minimum: true
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-}
 op {
   name: "ScatterAdd"
   input_arg {
@@ -32208,18 +31861,6 @@ op {
     }
   }
 }
-op {
-  name: "SerializeIterator"
-  input_arg {
-    name: "resource_handle"
-    type: DT_RESOURCE
-  }
-  output_arg {
-    name: "serialized"
-    type: DT_VARIANT
-  }
-  is_stateful: true
-}
 op {
   name: "SerializeManySparse"
   input_arg {
@@ -37624,38 +37265,6 @@ op {
     }
   }
 }
-op {
-  name: "SqlDataset"
-  input_arg {
-    name: "driver_name"
-    type: DT_STRING
-  }
-  input_arg {
-    name: "data_source_name"
-    type: DT_STRING
-  }
-  input_arg {
-    name: "query"
-    type: DT_STRING
-  }
-  output_arg {
-    name: "handle"
-    type: DT_VARIANT
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-  is_stateful: true
-}
 op {
   name: "Sqrt"
   input_arg {
diff --git a/tensorflow/core/ops/dataset_ops.cc b/tensorflow/core/ops/dataset_ops.cc
index f5122139645e2d3360bdcdbde29335ccaca79fbb..8f5d8308a3df6fada91737cef82b126dba72356e 100644
--- a/tensorflow/core/ops/dataset_ops.cc
+++ b/tensorflow/core/ops/dataset_ops.cc
@@ -141,16 +141,6 @@ count: A scalar representing the number of elements from the `input_dataset`
   that should be skipped.  If count is -1, skips everything.
 )doc");
 
-REGISTER_OP("IgnoreErrorsDataset")
-    .Input("input_dataset: variant")
-    .Output("handle: variant")
-    .Attr("output_types: list(type) >= 1")
-    .Attr("output_shapes: list(shape) >= 1")
-    .SetShapeFn(shape_inference::ScalarShape)
-    .Doc(R"doc(
-Creates a dataset that contains the elements of `input_dataset` ignoring errors.
-)doc");
-
 REGISTER_OP("MapDataset")
     .Input("input_dataset: variant")
     .Input("other_arguments: Targuments")
@@ -184,32 +174,6 @@ num_parallel_calls: The number of concurrent invocations of `f` that process
   elements from `input_dataset` in parallel.
 )doc");
 
-REGISTER_OP("MapAndBatchDataset")
-    .Input("input_dataset: variant")
-    .Input("other_arguments: Targuments")
-    .Input("batch_size: int64")
-    .Input("num_parallel_batches: int64")
-    .Output("handle: variant")
-    .Attr("f: func")
-    .Attr("Targuments: list(type) >= 0")
-    .Attr("output_types: list(type) >= 1")
-    .Attr("output_shapes: list(shape) >= 1")
-    .SetShapeFn(shape_inference::ScalarShape)
-    .Doc(R"doc(
-Creates a dataset that applies `f` to the outputs of `input_dataset` and then
-batches `batch_size` of them.
-
-Unlike a "MapDataset", which applies `f` sequentially, this dataset invokes up
-to `batch_size * num_parallel_batches` copies of `f` in parallel.
-
-batch_size: A scalar representing the number of elements to accumulate in a
-  batch. It determines the number of concurrent invocations of `f` that process
-  elements from `input_dataset` in parallel.
-num_parallel_batches: A scalar representing the number of batches to create in
-  parallel. Processing multiple batches in parallel benefits workloads prone to
-  stragglers.
-)doc");
-
 REGISTER_OP("PrefetchDataset")
     .Input("input_dataset: variant")
     .Input("buffer_size: int64")
@@ -224,21 +188,6 @@ buffer_size: The maximum number of elements to buffer in an iterator over
   this dataset.
 )doc");
 
-REGISTER_OP("ScanDataset")
-    .Input("input_dataset: variant")
-    .Input("initial_state: Tstate")
-    .Input("other_arguments: Targuments")
-    .Output("handle: variant")
-    .Attr("f: func")
-    .Attr("Tstate: list(type) >= 1")
-    .Attr("Targuments: list(type) >= 0")
-    .Attr("output_types: list(type) >= 1")
-    .Attr("output_shapes: list(shape) >= 1")
-    .SetShapeFn(shape_inference::ScalarShape)
-    .Doc(R"doc(
-Creates a dataset successively reduces `f` over the elements of `input_dataset`.
-)doc");
-
 REGISTER_OP("FlatMapDataset")
     .Input("input_dataset: variant")
     .Input("other_arguments: Targuments")
@@ -285,59 +234,6 @@ f: A function mapping elements of `input_dataset`, concatenated with
   `output_types` and `output_shapes`.
 )doc");
 
-REGISTER_OP("ParallelInterleaveDataset")
-    .Input("input_dataset: variant")
-    .Input("other_arguments: Targuments")
-    .Input("cycle_length: int64")
-    .Input("block_length: int64")
-    .Input("sloppy: bool")
-    .Output("handle: variant")
-    .Attr("f: func")
-    .Attr("Targuments: list(type) >= 0")
-    .Attr("output_types: list(type) >= 1")
-    .Attr("output_shapes: list(shape) >= 1")
-    .SetShapeFn(shape_inference::ScalarShape)
-    .Doc(R"doc(
-Creates a dataset that applies `f` to the outputs of `input_dataset`.
-
-The resulting dataset is similar to the `InterleaveDataset`, with the exception
-that if retrieving the next value from a dataset would cause the requester to
-block, it will skip that input dataset. This dataset is especially useful
-when loading data from a variable-latency datastores (e.g. HDFS, GCS), as it
-allows the training step to proceed so long as some data is available.
-
-!! WARNING !! This dataset is not deterministic!
-
-f: A function mapping elements of `input_dataset`, concatenated with
-   `other_arguments`, to a Dataset variant that contains elements matching
-   `output_types` and `output_shapes`.
-)doc");
-
-REGISTER_OP("GroupByWindowDataset")
-    .Input("input_dataset: variant")
-    .Input("key_func_other_arguments: Tkey_func_other_arguments")
-    .Input("reduce_func_other_arguments: Treduce_func_other_arguments")
-    .Input(
-        "window_size_func_other_arguments: Twindow_size_func_other_arguments")
-    .Output("handle: variant")
-    .Attr("key_func: func")
-    .Attr("reduce_func: func")
-    .Attr("window_size_func: func")
-    .Attr("Tkey_func_other_arguments: list(type) >= 0")
-    .Attr("Treduce_func_other_arguments: list(type) >= 0")
-    .Attr("Twindow_size_func_other_arguments: list(type) >= 0")
-    .Attr("output_types: list(type) >= 1")
-    .Attr("output_shapes: list(shape) >= 1")
-    .SetShapeFn(shape_inference::ScalarShape)
-    .Doc(R"doc(
-Creates a dataset that computes a windowed group-by on `input_dataset`.
-
-// TODO(mrry): Support non-int64 keys.
-
-key_func: A function mapping an element of `input_dataset`, concatenated
-  with `key_func_other_arguments` to a scalar value of type DT_INT64.
-)doc");
-
 REGISTER_OP("FilterDataset")
     .Input("input_dataset: variant")
     .Input("other_arguments: Targuments")
@@ -408,27 +304,6 @@ padding_values: A list of scalars containing the padding value to use for
   each of the outputs.
 )doc");
 
-REGISTER_OP("DenseToSparseBatchDataset")
-    .Input("input_dataset: variant")
-    .Input("batch_size: int64")
-    .Input("row_shape: int64")
-    .Output("handle: variant")
-    // NOTE(mrry): the 0th and 2nd elements will be DT_INT64.
-    .Attr("output_types: list(type) >= 1")
-    // NOTE(mrry): the 1st and 2nd elements will be vectors.
-    .Attr("output_shapes: list(shape) >= 1")
-    .SetShapeFn(shape_inference::ScalarShape)
-    .Doc(R"doc(
-Creates a dataset that yields a SparseTensor for each element of the input.
-
-input_dataset: A handle to an input dataset. Must have a single component.
-batch_size: A scalar representing the number of elements to accumulate in a
-  batch.
-row_shape: A vector representing the dense shape of each row in the produced
-  SparseTensor. The shape may be partially specified, using `-1` to indicate
-  that a particular dimension should use the maximum size of all batch elements.
-)doc");
-
 REGISTER_OP("RangeDataset")
     .Input("start: int64")
     .Input("stop: int64")
@@ -514,24 +389,6 @@ compression_type: A scalar containing either (i) the empty string (no
 buffer_size: A scalar containing the number of bytes to buffer.
 )doc");
 
-REGISTER_OP("SqlDataset")
-    .Input("driver_name: string")
-    .Input("data_source_name: string")
-    .Input("query: string")
-    .Output("handle: variant")
-    .Attr("output_types: list(type) >= 1")
-    .Attr("output_shapes: list(shape) >= 1")
-    .SetIsStateful()  // TODO(b/65524810): Source dataset ops must be marked
-                      // stateful to inhibit constant folding.
-    .SetShapeFn(shape_inference::ScalarShape)
-    .Doc(R"doc(
-Creates a dataset that executes a SQL query and emits rows of the result set.
-
-driver_name: The database type. Currently, the only supported type is 'sqlite'.
-data_source_name: A connection string to connect to the database.
-query: A SQL query to execute.
-)doc");
-
 REGISTER_OP("FixedLengthRecordDataset")
     .Input("filenames: string")
     .Input("header_bytes: int64")
@@ -662,36 +519,6 @@ REGISTER_OP("IteratorGetNext")
 Gets the next output from the given iterator.
 )doc");
 
-REGISTER_OP("DatasetToSingleElement")
-    .Input("dataset: variant")
-    .Output("components: output_types")
-    .Attr("output_types: list(type) >= 1")
-    .Attr("output_shapes: list(shape) >= 1")
-    .SetShapeFn([](shape_inference::InferenceContext* c) {
-      shape_inference::ShapeHandle unused;
-      TF_RETURN_IF_ERROR(c->WithRank(c->input(0), 0, &unused));
-      std::vector<PartialTensorShape> output_shapes;
-      TF_RETURN_IF_ERROR(c->GetAttr("output_shapes", &output_shapes));
-      if (output_shapes.size() != c->num_outputs()) {
-        return errors::InvalidArgument(
-            "`output_shapes` must be the same length as `output_types` (",
-            output_shapes.size(), " vs. ", c->num_outputs());
-      }
-      for (size_t i = 0; i < output_shapes.size(); ++i) {
-        shape_inference::ShapeHandle output_shape_handle;
-        TF_RETURN_IF_ERROR(c->MakeShapeFromPartialTensorShape(
-            output_shapes[i], &output_shape_handle));
-        c->set_output(static_cast<int>(i), output_shape_handle);
-      }
-      return Status::OK();
-    })
-    .Doc(R"doc(
-Outputs the single element from the given dataset.
-
-dataset: A handle to a dataset that contains a single element.
-components: The components of the single element of `input`.
-)doc");
-
 REGISTER_OP("IteratorToStringHandle")
     .Input("resource_handle: resource")
     .Output("string_handle: string")
@@ -720,28 +547,4 @@ output_shapes: If specified, defines the shape of each tuple component in an
   element produced by the resulting iterator.
 )doc");
 
-REGISTER_OP("SerializeIterator")
-    .Input("resource_handle: resource")
-    .Output("serialized: variant")
-    .SetShapeFn(shape_inference::ScalarShape)
-    .Doc(R"doc(
-Converts the given `resource_handle` representing an iterator to a variant tensor.
-
-resource_handle: A handle to an iterator resource.
-serialized: A variant tensor storing the state of the iterator contained in the
-  resource.
-)doc");
-
-REGISTER_OP("DeserializeIterator")
-    .Input("resource_handle: resource")
-    .Input("serialized: variant")
-    .SetShapeFn(shape_inference::NoOutputs)
-    .Doc(R"doc(
-Converts the given variant tensor to an iterator and stores it in the given resource.
-
-resource_handle: A handle to an iterator resource.
-serialized: A variant tensor storing the state of the iterator contained in the
-  resource.
-)doc");
-
 }  // namespace tensorflow
diff --git a/tensorflow/core/ops/linalg_ops.cc b/tensorflow/core/ops/linalg_ops.cc
index 4851619f833beff71e1976e63a60cd81fb78eff8..53e2360d2321a21c658f5abb87bfbc78e2564f26 100644
--- a/tensorflow/core/ops/linalg_ops.cc
+++ b/tensorflow/core/ops/linalg_ops.cc
@@ -282,6 +282,33 @@ Equivalent to np.linalg.inv
 @end_compatibility
 )doc");
 
+REGISTER_OP("MatrixExponential")
+    .Input("input: T")
+    .Output("output: T")
+    .Attr("T: {double, float, complex64, complex128}")
+    .SetShapeFn(BatchUnchangedSquareShapeFn)
+    .Doc(R"doc(
+Computes the matrix exponential of one or more square matrices:
+
+exp(A) = \sum_{n=0}^\infty A^n/n!
+
+The exponential is computed using a combination of the scaling and squaring
+method and the Pade approximation. Details can be founds in:
+Nicholas J. Higham, "The scaling and squaring method for the matrix exponential
+revisited," SIAM J. Matrix Anal. Applic., 26:1179-1193, 2005.
+
+The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+form square matrices. The output is a tensor of the same shape as the input
+containing the exponential for all input submatrices `[..., :, :]`.
+
+input: Shape is `[..., M, M]`.
+output: Shape is `[..., M, M]`.
+
+@compatibility(scipy)
+Equivalent to scipy.linalg.expm
+@end_compatibility
+)doc");
+
 REGISTER_OP("Cholesky")
     .Input("input: T")
     .Output("output: T")
diff --git a/tensorflow/core/ops/math_ops.cc b/tensorflow/core/ops/math_ops.cc
index 7b10af9f44dad7c9a28a7c37d57b3b5a69cc36a1..d30b84769677cac6fc5da65e6d785d830f929b17 100644
--- a/tensorflow/core/ops/math_ops.cc
+++ b/tensorflow/core/ops/math_ops.cc
@@ -1829,6 +1829,8 @@ need not be sorted and need not cover all values in the full
 range of valid values.
 
 If the sum is empty for a given segment ID `i`, `output[i] = 0`.
+If the given segment ID `i` is negative, the value is dropped and will not be
+added to the sum of the segment.
 
 `num_segments` should equal the number of distinct segment IDs.
 
diff --git a/tensorflow/core/ops/ops.pbtxt b/tensorflow/core/ops/ops.pbtxt
index 58d0fb3e73d5a04730d6862fad3d5cb10559d16b..2c73441e7dbb66cc3a5241429ab48d88a734cd8d 100644
--- a/tensorflow/core/ops/ops.pbtxt
+++ b/tensorflow/core/ops/ops.pbtxt
@@ -6063,32 +6063,6 @@ op {
   summary: "Compute the cumulative sum of the tensor `x` along `axis`."
   description: "By default, this op performs an inclusive cumsum, which means that the first\nelement of the input is identical to the first element of the output:\n\n```python\ntf.cumsum([a, b, c])  # => [a, a + b, a + b + c]\n```\n\nBy setting the `exclusive` kwarg to `True`, an exclusive cumsum is\nperformed instead:\n\n```python\ntf.cumsum([a, b, c], exclusive=True)  # => [0, a, a + b]\n```\n\nBy setting the `reverse` kwarg to `True`, the cumsum is performed in the\nopposite direction:\n\n```python\ntf.cumsum([a, b, c], reverse=True)  # => [a + b + c, b + c, c]\n```\n\nThis is more efficient than using separate `tf.reverse` ops.\n\nThe `reverse` and `exclusive` kwargs can also be combined:\n\n```python\ntf.cumsum([a, b, c], exclusive=True, reverse=True)  # => [b + c, c, 0]\n```"
 }
-op {
-  name: "DatasetToSingleElement"
-  input_arg {
-    name: "dataset"
-    description: "A handle to a dataset that contains a single element."
-    type: DT_VARIANT
-  }
-  output_arg {
-    name: "components"
-    description: "The components of the single element of `input`."
-    type_list_attr: "output_types"
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-  summary: "Outputs the single element from the given dataset."
-}
 op {
   name: "DebugGradientIdentity"
   input_arg {
@@ -6720,41 +6694,6 @@ op {
   summary: "Applies set operation along last dimension of 2 `Tensor` inputs."
   description: "See SetOperationOp::SetOperationFromContext for values of `set_operation`.\n\nOutput `result` is a `SparseTensor` represented by `result_indices`,\n`result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this\nhas rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`\ndimension contains the result of `set_operation` applied to the corresponding\n`[0...n-1]` dimension of `set`."
 }
-op {
-  name: "DenseToSparseBatchDataset"
-  input_arg {
-    name: "input_dataset"
-    description: "A handle to an input dataset. Must have a single component."
-    type: DT_VARIANT
-  }
-  input_arg {
-    name: "batch_size"
-    description: "A scalar representing the number of elements to accumulate in a\nbatch."
-    type: DT_INT64
-  }
-  input_arg {
-    name: "row_shape"
-    description: "A vector representing the dense shape of each row in the produced\nSparseTensor. The shape may be partially specified, using `-1` to indicate\nthat a particular dimension should use the maximum size of all batch elements."
-    type: DT_INT64
-  }
-  output_arg {
-    name: "handle"
-    type: DT_VARIANT
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-  summary: "Creates a dataset that yields a SparseTensor for each element of the input."
-}
 op {
   name: "DenseToSparseSetOperation"
   input_arg {
@@ -7094,21 +7033,6 @@ op {
   summary: "Dequantize the \'input\' tensor into a float Tensor."
   description: "[min_range, max_range] are scalar floats that specify the range for\nthe \'input\' data. The \'mode\' attribute controls exactly which calculations are\nused to convert the float values to their quantized equivalents.\n\nIn \'MIN_COMBINED\' mode, each value of the tensor will undergo the following:\n\n```\nif T == qint8, in[i] += (range(T) + 1)/ 2.0\nout[i] = min_range + (in[i]* (max_range - min_range) / range(T))\n```\nhere `range(T) = numeric_limits<T>::max() - numeric_limits<T>::min()`\n\n*MIN_COMBINED Mode Example*\n\nIf the input comes from a QuantizedRelu6, the output type is\nquint8 (range of 0-255) but the possible range of QuantizedRelu6 is\n0-6.  The min_range and max_range values are therefore 0.0 and 6.0.\nDequantize on quint8 will take each value, cast to float, and multiply\nby 6 / 255.\nNote that if quantizedtype is qint8, the operation will additionally add\neach value by 128 prior to casting.\n\nIf the mode is \'MIN_FIRST\', then this approach is used:\n\n```c++\nnum_discrete_values = 1 << (# of bits in T)\nrange_adjust = num_discrete_values / (num_discrete_values - 1)\nrange = (range_max - range_min) * range_adjust\nrange_scale = range / num_discrete_values\nconst double offset_input = static_cast<double>(input) - lowest_quantized;\nresult = range_min + ((input - numeric_limits<T>::min()) * range_scale)\n```\n\n*SCALED mode Example*\n\n`SCALED` mode matches the quantization approach used in\n`QuantizeAndDequantize{V2|V3}`.\n\nIf the mode is `SCALED`, we do not use the full range of the output type,\nchoosing to elide the lowest possible value for symmetry (e.g., output range is\n-127 to 127, not -128 to 127 for signed 8 bit quantization), so that 0.0 maps to\n0.\n\nWe first find the range of values in our tensor. The\nrange we use is always centered on 0, so we find m such that\n```c++\n  m = max(abs(input_min), abs(input_max))\n```\n\nOur input tensor range is then `[-m, m]`.\n\nNext, we choose our fixed-point quantization buckets, `[min_fixed, max_fixed]`.\nIf T is signed, this is\n```\n  num_bits = sizeof(T) * 8\n  [min_fixed, max_fixed] =\n      [-(1 << (num_bits - 1) - 1), (1 << (num_bits - 1)) - 1]\n```\n\nOtherwise, if T is unsigned, the fixed-point range is\n```\n  [min_fixed, max_fixed] = [0, (1 << num_bits) - 1]\n```\n\nFrom this we compute our scaling factor, s:\n```c++\n  s = (2 * m) / (max_fixed - min_fixed)\n```\n\nNow we can dequantize the elements of our tensor:\n```c++\nresult = input * s\n```"
 }
-op {
-  name: "DeserializeIterator"
-  input_arg {
-    name: "resource_handle"
-    description: "A handle to an iterator resource."
-    type: DT_RESOURCE
-  }
-  input_arg {
-    name: "serialized"
-    description: "A variant tensor storing the state of the iterator contained in the\nresource."
-    type: DT_VARIANT
-  }
-  summary: "Converts the given variant tensor to an iterator and stores it in the given resource."
-  is_stateful: true
-}
 op {
   name: "DeserializeManySparse"
   input_arg {
@@ -10082,8 +10006,18 @@ op {
     description: "Number of entries in the new vocab file to remap."
     has_minimum: true
   }
+  attr {
+    name: "old_vocab_size"
+    type: "int"
+    default_value {
+      i: -1
+    }
+    description: "Number of entries in the old vocab file to consider.  If -1,\nuse the entire old vocabulary."
+    has_minimum: true
+    minimum: -1
+  }
   summary: "Given a path to new and old vocabulary files, returns a remapping Tensor of"
-  description: "length `num_new_vocab`, where `remapping[i]` contains the row number in the old\nvocabulary that corresponds to row `i` in the new vocabulary (starting at line\n`new_vocab_offset` and up to `num_new_vocab` entities), or `-1` if entry `i`\nin the new vocabulary is not in the old vocabulary.  `num_vocab_offset` enables\nuse in the partitioned variable case, and should generally be set through\nexamining partitioning info.  The format of the files should be a text file,\nwith each line containing a single entity within the vocabulary.\n\nFor example, with `new_vocab_file` a text file containing each of the following\nelements on a single line: `[f0, f1, f2, f3]`, old_vocab_file = [f1, f0, f3],\n`num_new_vocab = 3, new_vocab_offset = 1`, the returned remapping would be\n`[0, -1, 2]`.\n\nThe op also returns a count of how many entries in the new vocabulary\nwere present in the old vocabulary, which is used to calculate the number of\nvalues to initialize in a weight matrix remapping\n\nThis functionality can be used to remap both row vocabularies (typically,\nfeatures) and column vocabularies (typically, classes) from TensorFlow\ncheckpoints.  Note that the partitioning logic relies on contiguous vocabularies\ncorresponding to div-partitioned variables.  Moreover, the underlying remapping\nuses an IndexTable (as opposed to an inexact CuckooTable), so client code should\nuse the corresponding index_table_from_file() as the FeatureColumn framework\ndoes (as opposed to tf.feature_to_id(), which uses a CuckooTable)."
+  description: "length `num_new_vocab`, where `remapping[i]` contains the row number in the old\nvocabulary that corresponds to row `i` in the new vocabulary (starting at line\n`new_vocab_offset` and up to `num_new_vocab` entities), or `-1` if entry `i`\nin the new vocabulary is not in the old vocabulary.  The old vocabulary is\nconstrained to the first `old_vocab_size` entries if `old_vocab_size` is not the\ndefault value of -1.\n\n`num_vocab_offset` enables\nuse in the partitioned variable case, and should generally be set through\nexamining partitioning info.  The format of the files should be a text file,\nwith each line containing a single entity within the vocabulary.\n\nFor example, with `new_vocab_file` a text file containing each of the following\nelements on a single line: `[f0, f1, f2, f3]`, old_vocab_file = [f1, f0, f3],\n`num_new_vocab = 3, new_vocab_offset = 1`, the returned remapping would be\n`[0, -1, 2]`.\n\nThe op also returns a count of how many entries in the new vocabulary\nwere present in the old vocabulary, which is used to calculate the number of\nvalues to initialize in a weight matrix remapping\n\nThis functionality can be used to remap both row vocabularies (typically,\nfeatures) and column vocabularies (typically, classes) from TensorFlow\ncheckpoints.  Note that the partitioning logic relies on contiguous vocabularies\ncorresponding to div-partitioned variables.  Moreover, the underlying remapping\nuses an IndexTable (as opposed to an inexact CuckooTable), so client code should\nuse the corresponding index_table_from_file() as the FeatureColumn framework\ndoes (as opposed to tf.feature_to_id(), which uses a CuckooTable)."
 }
 op {
   name: "GetSessionHandle"
@@ -10213,71 +10147,6 @@ op {
   summary: "Returns the truth value of (x >= y) element-wise."
   description: "*NOTE*: `GreaterEqual` supports broadcasting. More about broadcasting\n[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)"
 }
-op {
-  name: "GroupByWindowDataset"
-  input_arg {
-    name: "input_dataset"
-    type: DT_VARIANT
-  }
-  input_arg {
-    name: "key_func_other_arguments"
-    type_list_attr: "Tkey_func_other_arguments"
-  }
-  input_arg {
-    name: "reduce_func_other_arguments"
-    type_list_attr: "Treduce_func_other_arguments"
-  }
-  input_arg {
-    name: "window_size_func_other_arguments"
-    type_list_attr: "Twindow_size_func_other_arguments"
-  }
-  output_arg {
-    name: "handle"
-    type: DT_VARIANT
-  }
-  attr {
-    name: "key_func"
-    type: "func"
-    description: "A function mapping an element of `input_dataset`, concatenated\nwith `key_func_other_arguments` to a scalar value of type DT_INT64."
-  }
-  attr {
-    name: "reduce_func"
-    type: "func"
-  }
-  attr {
-    name: "window_size_func"
-    type: "func"
-  }
-  attr {
-    name: "Tkey_func_other_arguments"
-    type: "list(type)"
-    has_minimum: true
-  }
-  attr {
-    name: "Treduce_func_other_arguments"
-    type: "list(type)"
-    has_minimum: true
-  }
-  attr {
-    name: "Twindow_size_func_other_arguments"
-    type: "list(type)"
-    has_minimum: true
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-  summary: "Creates a dataset that computes a windowed group-by on `input_dataset`."
-  description: "// TODO(mrry): Support non-int64 keys."
-}
 op {
   name: "HSVToRGB"
   input_arg {
@@ -10738,30 +10607,6 @@ op {
   summary: "Compute the upper regularized incomplete Gamma function `Q(a, x)`."
   description: "The upper regularized incomplete Gamma function is defined as:\n\n\\\\(Q(a, x) = Gamma(a, x) / Gamma(a) = 1 - P(a, x)\\\\)\n\nwhere\n\n\\\\(Gamma(a, x) = int_{x}^{\\infty} t^{a-1} exp(-t) dt\\\\)\n\nis the upper incomplete Gama function.\n\nNote, above `P(a, x)` (`Igamma`) is the lower regularized complete\nGamma function."
 }
-op {
-  name: "IgnoreErrorsDataset"
-  input_arg {
-    name: "input_dataset"
-    type: DT_VARIANT
-  }
-  output_arg {
-    name: "handle"
-    type: DT_VARIANT
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-  summary: "Creates a dataset that contains the elements of `input_dataset` ignoring errors."
-}
 op {
   name: "Imag"
   input_arg {
@@ -12533,54 +12378,6 @@ op {
   description: "This operation may be executed multiple times. Each execution will reset the\niterator in `iterator` to the first element of `dataset`."
   is_stateful: true
 }
-op {
-  name: "MapAndBatchDataset"
-  input_arg {
-    name: "input_dataset"
-    type: DT_VARIANT
-  }
-  input_arg {
-    name: "other_arguments"
-    type_list_attr: "Targuments"
-  }
-  input_arg {
-    name: "batch_size"
-    description: "A scalar representing the number of elements to accumulate in a\nbatch. It determines the number of concurrent invocations of `f` that process\nelements from `input_dataset` in parallel."
-    type: DT_INT64
-  }
-  input_arg {
-    name: "num_parallel_batches"
-    description: "A scalar representing the number of batches to create in\nparallel. Processing multiple batches in parallel benefits workloads prone to\nstragglers."
-    type: DT_INT64
-  }
-  output_arg {
-    name: "handle"
-    type: DT_VARIANT
-  }
-  attr {
-    name: "f"
-    type: "func"
-  }
-  attr {
-    name: "Targuments"
-    type: "list(type)"
-    has_minimum: true
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-  summary: "Creates a dataset that applies `f` to the outputs of `input_dataset` and then"
-  description: "batches `batch_size` of them.\n\nUnlike a \"MapDataset\", which applies `f` sequentially, this dataset invokes up\nto `batch_size * num_parallel_batches` copies of `f` in parallel."
-}
 op {
   name: "MapClear"
   attr {
@@ -13123,6 +12920,33 @@ op {
   summary: "Returns the batched diagonal part of a batched tensor."
   description: "This operation returns a tensor with the `diagonal` part\nof the batched `input`. The `diagonal` part is computed as follows:\n\nAssume `input` has `k` dimensions `[I, J, K, ..., M, N]`, then the output is a\ntensor of rank `k - 1` with dimensions `[I, J, K, ..., min(M, N)]` where:\n\n`diagonal[i, j, k, ..., n] = input[i, j, k, ..., n, n]`.\n\nThe input must be at least a matrix.\n\nFor example:\n\n```\n# \'input\' is [[[1, 0, 0, 0]\n               [0, 2, 0, 0]\n               [0, 0, 3, 0]\n               [0, 0, 0, 4]],\n              [[5, 0, 0, 0]\n               [0, 6, 0, 0]\n               [0, 0, 7, 0]\n               [0, 0, 0, 8]]]\n\nand input.shape = (2, 4, 4)\n\ntf.matrix_diag_part(input) ==> [[1, 2, 3, 4], [5, 6, 7, 8]]\n\nwhich has shape (2, 4)\n```"
 }
+op {
+  name: "MatrixExponential"
+  input_arg {
+    name: "input"
+    description: "Shape is `[..., M, M]`."
+    type_attr: "T"
+  }
+  output_arg {
+    name: "output"
+    description: "Shape is `[..., M, M]`.\n\n@compatibility(scipy)\nEquivalent to scipy.linalg.expm\n@end_compatibility"
+    type_attr: "T"
+  }
+  attr {
+    name: "T"
+    type: "type"
+    allowed_values {
+      list {
+        type: DT_DOUBLE
+        type: DT_FLOAT
+        type: DT_COMPLEX64
+        type: DT_COMPLEX128
+      }
+    }
+  }
+  summary: "Computes the matrix exponential of one or more square matrices:"
+  description: "exp(A) = \\sum_{n=0}^\\infty A^n/n!\n\nThe exponential is computed using a combination of the scaling and squaring\nmethod and the Pade approximation. Details can be founds in:\nNicholas J. Higham, \"The scaling and squaring method for the matrix exponential\nrevisited,\" SIAM J. Matrix Anal. Applic., 26:1179-1193, 2005.\n\nThe input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions\nform square matrices. The output is a tensor of the same shape as the input\ncontaining the exponential for all input submatrices `[..., :, :]`."
+}
 op {
   name: "MatrixInverse"
   input_arg {
@@ -16224,57 +16048,6 @@ op {
   summary: "Interleave the values from the `data` tensors into a single tensor."
   description: "Builds a merged tensor such that\n\n```python\n    merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]\n```\n\nFor example, if each `indices[m]` is scalar or vector, we have\n\n```python\n    # Scalar indices:\n    merged[indices[m], ...] = data[m][...]\n\n    # Vector indices:\n    merged[indices[m][i], ...] = data[m][i, ...]\n```\n\nEach `data[i].shape` must start with the corresponding `indices[i].shape`,\nand the rest of `data[i].shape` must be constant w.r.t. `i`.  That is, we\nmust have `data[i].shape = indices[i].shape + constant`.  In terms of this\n`constant`, the output shape is\n\n    merged.shape = [max(indices)] + constant\n\nValues may be merged in parallel, so if an index appears in both `indices[m][i]`\nand `indices[n][j]`, the result may be invalid. This differs from the normal\nDynamicStitch operator that defines the behavior in that case.\n\nFor example:\n\n```python\n    indices[0] = 6\n    indices[1] = [4, 1]\n    indices[2] = [[5, 2], [0, 3]]\n    data[0] = [61, 62]\n    data[1] = [[41, 42], [11, 12]]\n    data[2] = [[[51, 52], [21, 22]], [[1, 2], [31, 32]]]\n    merged = [[1, 2], [11, 12], [21, 22], [31, 32], [41, 42],\n              [51, 52], [61, 62]]\n```\n\nThis method can be used to merge partitions created by `dynamic_partition`\nas illustrated on the following example:\n\n```python\n    # Apply function (increments x_i) on elements for which a certain condition\n    # apply (x_i != -1 in this example).\n    x=tf.constant([0.1, -1., 5.2, 4.3, -1., 7.4])\n    condition_mask=tf.not_equal(x,tf.constant(-1.))\n    partitioned_data = tf.dynamic_partition(\n        x, tf.cast(condition_mask, tf.int32) , 2)\n    partitioned_data[1] = partitioned_data[1] + 1.0\n    condition_indices = tf.dynamic_partition(\n        tf.range(tf.shape(x)[0]), tf.cast(condition_mask, tf.int32) , 2)\n    x = tf.dynamic_stitch(condition_indices, partitioned_data)\n    # Here x=[1.1, -1., 6.2, 5.3, -1, 8.4], the -1. values remain\n    # unchanged.\n```\n\n<div style=\"width:70%; margin:auto; margin-bottom:10px; margin-top:20px;\">\n<img style=\"width:100%\" src=\"https://www.tensorflow.org/images/DynamicStitch.png\" alt>\n</div>"
 }
-op {
-  name: "ParallelInterleaveDataset"
-  input_arg {
-    name: "input_dataset"
-    type: DT_VARIANT
-  }
-  input_arg {
-    name: "other_arguments"
-    type_list_attr: "Targuments"
-  }
-  input_arg {
-    name: "cycle_length"
-    type: DT_INT64
-  }
-  input_arg {
-    name: "block_length"
-    type: DT_INT64
-  }
-  input_arg {
-    name: "sloppy"
-    type: DT_BOOL
-  }
-  output_arg {
-    name: "handle"
-    type: DT_VARIANT
-  }
-  attr {
-    name: "f"
-    type: "func"
-    description: "A function mapping elements of `input_dataset`, concatenated with\n`other_arguments`, to a Dataset variant that contains elements matching\n`output_types` and `output_shapes`."
-  }
-  attr {
-    name: "Targuments"
-    type: "list(type)"
-    has_minimum: true
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-  summary: "Creates a dataset that applies `f` to the outputs of `input_dataset`."
-  description: "The resulting dataset is similar to the `InterleaveDataset`, with the exception\nthat if retrieving the next value from a dataset would cause the requester to\nblock, it will skip that input dataset. This dataset is especially useful\nwhen loading data from a variable-latency datastores (e.g. HDFS, GCS), as it\nallows the training step to proceed so long as some data is available.\n\n!! WARNING !! This dataset is not deterministic!"
-}
 op {
   name: "ParallelMapDataset"
   input_arg {
@@ -24082,53 +23855,6 @@ op {
   summary: "Outputs a `Summary` protocol buffer with scalar values."
   description: "The input `tags` and `values` must have the same shape.  The generated summary\nhas a summary value for each tag-value pair in `tags` and `values`."
 }
-op {
-  name: "ScanDataset"
-  input_arg {
-    name: "input_dataset"
-    type: DT_VARIANT
-  }
-  input_arg {
-    name: "initial_state"
-    type_list_attr: "Tstate"
-  }
-  input_arg {
-    name: "other_arguments"
-    type_list_attr: "Targuments"
-  }
-  output_arg {
-    name: "handle"
-    type: DT_VARIANT
-  }
-  attr {
-    name: "f"
-    type: "func"
-  }
-  attr {
-    name: "Tstate"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "Targuments"
-    type: "list(type)"
-    has_minimum: true
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-  summary: "Creates a dataset successively reduces `f` over the elements of `input_dataset`."
-}
 op {
   name: "ScatterAdd"
   input_arg {
@@ -25323,21 +25049,6 @@ op {
   }
   summary: "Computes gradients for the scaled exponential linear (Selu) operation."
 }
-op {
-  name: "SerializeIterator"
-  input_arg {
-    name: "resource_handle"
-    description: "A handle to an iterator resource."
-    type: DT_RESOURCE
-  }
-  output_arg {
-    name: "serialized"
-    description: "A variant tensor storing the state of the iterator contained in the\nresource."
-    type: DT_VARIANT
-  }
-  summary: "Converts the given `resource_handle` representing an iterator to a variant tensor."
-  is_stateful: true
-}
 op {
   name: "SerializeManySparse"
   input_arg {
@@ -29248,42 +28959,6 @@ op {
   }
   summary: "Splits a tensor into `num_split` tensors along one dimension."
 }
-op {
-  name: "SqlDataset"
-  input_arg {
-    name: "driver_name"
-    description: "The database type. Currently, the only supported type is \'sqlite\'."
-    type: DT_STRING
-  }
-  input_arg {
-    name: "data_source_name"
-    description: "A connection string to connect to the database."
-    type: DT_STRING
-  }
-  input_arg {
-    name: "query"
-    description: "A SQL query to execute."
-    type: DT_STRING
-  }
-  output_arg {
-    name: "handle"
-    type: DT_VARIANT
-  }
-  attr {
-    name: "output_types"
-    type: "list(type)"
-    has_minimum: true
-    minimum: 1
-  }
-  attr {
-    name: "output_shapes"
-    type: "list(shape)"
-    has_minimum: true
-    minimum: 1
-  }
-  summary: "Creates a dataset that executes a SQL query and emits rows of the result set."
-  is_stateful: true
-}
 op {
   name: "Sqrt"
   input_arg {
diff --git a/tensorflow/docs_src/install/install_c.md b/tensorflow/docs_src/install/install_c.md
index 3a153e81145676aab7e9f95f9d1c78fa7531a2cc..df622c6ac57907122e4d236e3623d947dc35ac58 100644
--- a/tensorflow/docs_src/install/install_c.md
+++ b/tensorflow/docs_src/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-${TF_TYPE}-${OS}-x86_64-1.4.0-rc1.tar.gz" |
+           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-${TF_TYPE}-${OS}-x86_64-1.4.0.tar.gz" |
            sudo tar -C $TARGET_DIRECTORY -xz
 
      The `tar` command extracts the TensorFlow C library into the `lib`
diff --git a/tensorflow/docs_src/install/install_go.md b/tensorflow/docs_src/install/install_go.md
index df43255896eb5084431be8336a5778d17607fd3f..8b3da49a0d4bca1b2bc2293520e0b946a7727c88 100644
--- a/tensorflow/docs_src/install/install_go.md
+++ b/tensorflow/docs_src/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-${TF_TYPE}-$(go env GOOS)-x86_64-1.4.0-rc1.tar.gz" |
+           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-${TF_TYPE}-$(go env GOOS)-x86_64-1.4.0.tar.gz" |
          sudo tar -C $TARGET_DIRECTORY -xz
 
      The `tar` command extracts the TensorFlow C library into the `lib`
diff --git a/tensorflow/docs_src/install/install_java.md b/tensorflow/docs_src/install/install_java.md
index f7f2c3cdc71787a9ce93e323a29b07e6e6a7779d..6eb81582491899c9c278c41fb39ae21d7fc3f4a9 100644
--- a/tensorflow/docs_src/install/install_java.md
+++ b/tensorflow/docs_src/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.4.0-rc1</version>
+  <version>1.4.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.4.0-rc1</version>
+                 <version>1.4.0</version>
                </dependency>
              </dependencies>
          </project>
@@ -124,7 +124,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.4.0-rc1.jar),
+     [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.4.0.jar),
      which is the TensorFlow Java Archive (JAR).
 
   2. Decide whether you will run TensorFlow for Java on CPU(s) only or with
@@ -143,7 +143,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-${TF_TYPE}-${OS}-x86_64-1.4.0-rc1.tar.gz" |
+           "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-${TF_TYPE}-${OS}-x86_64-1.4.0.tar.gz" |
            tar -xz -C ./jni
 
 ### Install on Windows
@@ -151,10 +151,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.4.0-rc1.jar),
+     [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.4.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.4.0-rc1.zip).
+     [TensorFlow for Java on Windows](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-cpu-windows-x86_64-1.4.0.zip).
   3. Extract this .zip file.
 
 
@@ -202,7 +202,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.4.0-rc1.jar HelloTF.java</b></pre>
+<pre><b>javac -cp libtensorflow-1.4.0.jar HelloTF.java</b></pre>
 
 
 ### Running
@@ -216,11 +216,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.4.0-rc1.jar:. -Djava.library.path=./jni HelloTF</b></pre>
+<pre><b>java -cp libtensorflow-1.4.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.4.0-rc1.jar;. -Djava.library.path=jni HelloTF</b></pre>
+<pre><b>java -cp libtensorflow-1.4.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/tensorflow/docs_src/install/install_linux.md b/tensorflow/docs_src/install/install_linux.md
index 414ab7b1f7def3d43b717c628979b291fd9244f0..f7380bac8a7a378ff8682064147f443716576ad3 100644
--- a/tensorflow/docs_src/install/install_linux.md
+++ b/tensorflow/docs_src/install/install_linux.md
@@ -188,7 +188,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.4.0rc1-cp34-cp34m-linux_x86_64.whl</b></pre>
+     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.4.0-cp34-cp34m-linux_x86_64.whl</b></pre>
 
 If you encounter installation problems, see
 [Common Installation Problems](#common_installation_problems).
@@ -293,7 +293,7 @@ take the following steps:
 
      <pre>
      $ <b>sudo pip3 install --upgrade \
-     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.4.0rc1-cp34-cp34m-linux_x86_64.whl</b>
+     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.4.0-cp34-cp34m-linux_x86_64.whl</b>
      </pre>
 
      If this step fails, see
@@ -480,7 +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.4.0rc1-cp34-cp34m-linux_x86_64.whl</b></pre>
+     https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.4.0-cp34-cp34m-linux_x86_64.whl</b></pre>
 
 
 <a name="ValidateYourInstallation"></a>
@@ -648,14 +648,14 @@ This section documents the relevant values for Linux installations.
 CPU only:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.4.0rc1-cp27-none-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.4.0-cp27-none-linux_x86_64.whl
 </pre>
 
 
 GPU support:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.4.0rc1-cp27-none-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.4.0-cp27-none-linux_x86_64.whl
 </pre>
 
 Note that GPU support requires the NVIDIA hardware and software described in
@@ -667,14 +667,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.4.0rc1-cp34-cp34m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.4.0-cp34-cp34m-linux_x86_64.whl
 </pre>
 
 
 GPU support:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.4.0rc1-cp34-cp34m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.4.0-cp34-cp34m-linux_x86_64.whl
 </pre>
 
 Note that GPU support requires the NVIDIA hardware and software described in
@@ -686,14 +686,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.4.0rc1-cp35-cp35m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.4.0-cp35-cp35m-linux_x86_64.whl
 </pre>
 
 
 GPU support:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.4.0rc1-cp35-cp35m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.4.0-cp35-cp35m-linux_x86_64.whl
 </pre>
 
 
@@ -705,14 +705,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.4.0rc1-cp36-cp36m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.4.0-cp36-cp36m-linux_x86_64.whl
 </pre>
 
 
 GPU support:
 
 <pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.4.0rc1-cp36-cp36m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.4.0-cp36-cp36m-linux_x86_64.whl
 </pre>
 
 
diff --git a/tensorflow/docs_src/install/install_mac.md b/tensorflow/docs_src/install/install_mac.md
index 9a95710bfa78ab546bc9e7ff1c8bd33ccd8b23c8..79b383817b4865dab20232b453d522c2613f9e9d 100644
--- a/tensorflow/docs_src/install/install_mac.md
+++ b/tensorflow/docs_src/install/install_mac.md
@@ -114,7 +114,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.4.0rc1-py2-none-any.whl</b></pre>
+     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.4.0-py2-none-any.whl</b></pre>
 
 If you encounter installation problems, see
 [Common Installation Problems](#common-installation-problems).
@@ -235,7 +235,7 @@ take the following steps:
      issue the following command:
 
      <pre> $ <b>sudo pip3 install --upgrade \
-     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.4.0rc1-py2-none-any.whl</b> </pre>
+     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.4.0-py2-none-any.whl</b> </pre>
 
      If the preceding command fails, see
      [installation problems](#common-installation-problems).
@@ -344,7 +344,7 @@ Take the following steps to install TensorFlow in an Anaconda environment:
      TensorFlow for Python 2.7:
 
      <pre> (tensorflow)$ <b>pip install --ignore-installed --upgrade \
-     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.4.0rc1-py2-none-any.whl</b></pre>
+     https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.4.0-py2-none-any.whl</b></pre>
 
 
 <a name="ValidateYourInstallation"></a>
@@ -517,7 +517,7 @@ This section documents the relevant values for Mac OS installations.
 
 
 <pre>
-https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.4.0rc1-py2-none-any.whl
+https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.4.0-py2-none-any.whl
 </pre>
 
 
@@ -525,7 +525,7 @@ https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.4.0rc1-py2-none-a
 
 
 <pre>
-https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.4.0rc1-py3-none-any.whl
+https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.4.0-py3-none-any.whl
 </pre>
 
 
diff --git a/tensorflow/docs_src/install/install_sources.md b/tensorflow/docs_src/install/install_sources.md
index 6d0dcdcd4ae7f884b4afbd4803aebeb672a955d1..aa4ae6c876fbe85e55be6b633d47ef97afa8c1e6 100644
--- a/tensorflow/docs_src/install/install_sources.md
+++ b/tensorflow/docs_src/install/install_sources.md
@@ -355,10 +355,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.4.0rc1 on Linux:
+for TensorFlow 1.4.0 on Linux:
 
 <pre>
-$ <b>sudo pip install /tmp/tensorflow_pkg/tensorflow-1.4.0rc1-py2-none-any.whl</b>
+$ <b>sudo pip install /tmp/tensorflow_pkg/tensorflow-1.4.0-py2-none-any.whl</b>
 </pre>
 
 ## Validate your installation
@@ -447,8 +447,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.4.0rc1</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.4.5</td><td>N/A</td><td>N/A</td></tr>
-<tr><td>tensorflow_gpu-1.4.0rc1</td><td>GPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.4.5</td><td>6</td><td>8</td></tr>
+<tr><td>tensorflow-1.4.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.5.4</td><td>N/A</td><td>N/A</td></tr>
+<tr><td>tensorflow_gpu-1.4.0</td><td>GPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.5.4</td><td>6</td><td>8</td></tr>
+ <tr><td>tensorflow-1.3.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.4.5</td><td>N/A</td><td>N/A</td></tr>
+<tr><td>tensorflow_gpu-1.3.0</td><td>GPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.4.5</td><td>6</td><td>8</td></tr>
 <tr><td>tensorflow-1.2.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.4.5</td><td>N/A</td><td>N/A</td></tr>
 <tr><td>tensorflow_gpu-1.2.0</td><td>GPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.4.5</td><td>5.1</td><td>8</td></tr>
 <tr><td>tensorflow-1.1.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>GCC 4.8</td><td>Bazel 0.4.2</td><td>N/A</td><td>N/A</td></tr>
@@ -460,7 +462,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.4.0rc1</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>Clang from xcode</td><td>Bazel 0.4.5</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>
+ <tr><td>tensorflow-1.3.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>Clang from xcode</td><td>Bazel 0.4.5</td><td>N/A</td><td>N/A</td></tr>
 <tr><td>tensorflow-1.2.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>Clang from xcode</td><td>Bazel 0.4.5</td><td>N/A</td><td>N/A</td></tr>
 <tr><td>tensorflow-1.1.0</td><td>CPU</td><td>2.7, 3.3-3.6</td><td>Clang from xcode</td><td>Bazel 0.4.2</td><td>N/A</td><td>N/A</td></tr>
 <tr><td>tensorflow_gpu-1.1.0</td><td>GPU</td><td>2.7, 3.3-3.6</td><td>Clang from xcode</td><td>Bazel 0.4.2</td><td>5.1</td><td>8</td></tr>
@@ -471,8 +474,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.4.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.4.0rc1</td><td>GPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>6</td><td>8</td></tr>
+<tr><td>tensorflow-1.4.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.4.0</td><td>GPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>6</td><td>8</td></tr>
+<tr><td>tensorflow-1.3.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.3.0</td><td>GPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>6</td><td>8</td></tr>
 <tr><td>tensorflow-1.2.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.2.0</td><td>GPU</td><td>3.5-3.6</td><td>MSVC 2015 update 3</td><td>Cmake v3.6.3</td><td>5.1</td><td>8</td></tr>
 <tr><td>tensorflow-1.1.0</td><td>CPU</td><td>3.5</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/tensorflow/docs_src/tutorials/wide.md b/tensorflow/docs_src/tutorials/wide.md
index 415a9d223a67ed98d84247d30422563616a4d717..68dda1f2222b4175cd891d727065c93da6a5e68f 100644
--- a/tensorflow/docs_src/tutorials/wide.md
+++ b/tensorflow/docs_src/tutorials/wide.md
@@ -119,6 +119,7 @@ def input_fn(data_file, num_epochs, shuffle, batch_size):
   assert tf.gfile.Exists(data_file), (
       '%s not found. Please make sure you have either run data_download.py or '
       'set both arguments --train_data and --test_data.' % data_file)
+
   def parse_csv(value):
     print('Parsing', data_file)
     columns = tf.decode_csv(value, record_defaults=_CSV_COLUMN_DEFAULTS)
@@ -127,24 +128,21 @@ def input_fn(data_file, num_epochs, shuffle, batch_size):
     return features, tf.equal(labels, '>50K')
 
   # Extract lines from input files using the Dataset API.
-  dataset = tf.contrib.data.TextLineDataset(data_file)
-  dataset = dataset.map(parse_csv, num_threads=5)
+  dataset = tf.data.TextLineDataset(data_file)
 
-  # Apply transformations to the Dataset
-  dataset = dataset.batch(batch_size)
+  if shuffle:
+    dataset = dataset.shuffle(buffer_size=_SHUFFLE_BUFFER)
+
+  dataset = dataset.map(parse_csv, num_parallel_calls=5)
+
+  # We call repeat after shuffling, rather than before, to prevent separate
+  # epochs from blending together.
   dataset = dataset.repeat(num_epochs)
+  dataset = dataset.batch(batch_size)
 
-  # Input function that is called by the Estimator
-  def _input_fn():
-    if shuffle:
-      # Apply shuffle transformation to re-shuffle the dataset in each call.
-      shuffled_dataset = dataset.shuffle(buffer_size=100000)
-      iterator = shuffled_dataset.make_one_shot_iterator()
-    else:
-      iterator = dataset.make_one_shot_iterator()
-    features, labels = iterator.get_next()
-    return features, labels
-  return _input_fn
+  iterator = dataset.make_one_shot_iterator()
+  features, labels = iterator.get_next()
+  return features, labels
 ```
 
 ## Selecting and Engineering Features for the Model
@@ -331,7 +329,7 @@ crossed_columns = [
 
 model_dir = tempfile.mkdtemp()
 model = tf.estimator.LinearClassifier(
-        model_dir=model_dir, feature_columns=base_columns + crossed_columns)
+    model_dir=model_dir, feature_columns=base_columns + crossed_columns)
 ```
 
 The model also automatically learns a bias term, which controls the prediction
@@ -346,30 +344,22 @@ train the model. Training a model is just a single command using the
 tf.estimator API:
 
 ```python
-model.train(input_fn=input_fn(
-      data_file=train_data,
-      num_epochs=num_epochs,
-      shuffle=True,
-      batch_size=batch_size))
+model.train(input_fn=lambda: input_fn(train_data, num_epochs, True, batch_size))
 ```
 
 After the model is trained, we can evaluate how good our model is at predicting
 the labels of the holdout data:
 
 ```python
-results = model.evaluate(input_fn=input_fn(
-      data_file=test_data,
-      num_epochs=1,
-      shuffle=False,
-      batch_size=batch_size))
-print('model directory = %s' % model_dir)
+results = model.evaluate(input_fn=lambda: input_fn(
+    test_data, 1, False, batch_size))
 for key in sorted(results):
   print('%s: %s' % (key, results[key]))
 ```
 
-The first line of the 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!
+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!
 
 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)
@@ -415,17 +405,17 @@ you a desirable model size.
 Finally, let's take a minute to talk about what the Logistic Regression model
 actually looks like in case you're not already familiar with it. We'll denote
 the label as \\(Y\\), and the set of observed features as a feature vector
-\\(\mathbf{x}=[x_1, x_2, ..., x_d]\\). We define \\(Y=1\\) if an individual earned >
-50,000 dollars and \\(Y=0\\) otherwise. In Logistic Regression, the probability of
-the label being positive (\\(Y=1\\)) given the features \\(\mathbf{x}\\) is given
-as:
+\\(\mathbf{x}=[x_1, x_2, ..., x_d]\\). We define \\(Y=1\\) if an individual
+earned > 50,000 dollars and \\(Y=0\\) otherwise. In Logistic Regression, the
+probability of the label being positive (\\(Y=1\\)) given the features
+\\(\mathbf{x}\\) is given as:
 
 $$ P(Y=1|\mathbf{x}) = \frac{1}{1+\exp(-(\mathbf{w}^T\mathbf{x}+b))}$$
 
-where \\(\mathbf{w}=[w_1, w_2, ..., w_d]\\) are the model weights for the features
-\\(\mathbf{x}=[x_1, x_2, ..., x_d]\\). \\(b\\) is a constant that is often called
-the **bias** of the model. The equation consists of two parts—A linear model and
-a logistic function:
+where \\(\mathbf{w}=[w_1, w_2, ..., w_d]\\) are the model weights for the
+features \\(\mathbf{x}=[x_1, x_2, ..., x_d]\\). \\(b\\) is a constant that is
+often called the **bias** of the model. The equation consists of two parts—A
+linear model and a logistic function:
 
 *   **Linear Model**: First, we can see that \\(\mathbf{w}^T\mathbf{x}+b = b +
     w_1x_1 + ... +w_dx_d\\) is a linear model where the output is a linear
@@ -433,16 +423,17 @@ a logistic function:
     prediction one would make without observing any features. The model weight
     \\(w_i\\) reflects how the feature \\(x_i\\) is correlated with the positive
     label. If \\(x_i\\) is positively correlated with the positive label, the
-    weight \\(w_i\\) increases, and the probability \\(P(Y=1|\mathbf{x})\\) will be
-    closer to 1. On the other hand, if \\(x_i\\) is negatively correlated with the
-    positive label, then the weight \\(w_i\\) decreases and the probability
-    \\(P(Y=1|\mathbf{x})\\) will be closer to 0.
+    weight \\(w_i\\) increases, and the probability \\(P(Y=1|\mathbf{x})\\) will
+    be closer to 1. On the other hand, if \\(x_i\\) is negatively correlated
+    with the positive label, then the weight \\(w_i\\) decreases and the
+    probability \\(P(Y=1|\mathbf{x})\\) will be closer to 0.
 
 *   **Logistic Function**: Second, we can see that there's a logistic function
-    (also known as the sigmoid function) \\(S(t) = 1/(1+\exp(-t))\\) being applied
-    to the linear model. The logistic function is used to convert the output of
-    the linear model \\(\mathbf{w}^T\mathbf{x}+b\\) from any real number into the
-    range of \\([0, 1]\\), which can be interpreted as a probability.
+    (also known as the sigmoid function) \\(S(t) = 1/(1+\exp(-t))\\) being
+    applied to the linear model. The logistic function is used to convert the
+    output of the linear model \\(\mathbf{w}^T\mathbf{x}+b\\) from any real
+    number into the range of \\([0, 1]\\), which can be interpreted as a
+    probability.
 
 Model training is an optimization problem: The goal is to find a set of model
 weights (i.e. model parameters) to minimize a **loss function** defined over the
diff --git a/tensorflow/docs_src/tutorials/wide_and_deep.md b/tensorflow/docs_src/tutorials/wide_and_deep.md
index 3f65779b1dd5027cab0b292eca4a9acedc3a278b..44677a810bc5c253c198d81fae2be723c4f8ae4e 100644
--- a/tensorflow/docs_src/tutorials/wide_and_deep.md
+++ b/tensorflow/docs_src/tutorials/wide_and_deep.md
@@ -199,10 +199,10 @@ handled for you under the hood, so you simply need to create a
 
 ```python
 model = tf.estimator.DNNLinearCombinedClassifier(
-            model_dir='/tmp/census_model',
-            linear_feature_columns=base_columns + crossed_columns,
-            dnn_feature_columns=deep_columns,
-            dnn_hidden_units=[100, 50])
+    model_dir='/tmp/census_model',
+    linear_feature_columns=base_columns + crossed_columns,
+    dnn_feature_columns=deep_columns,
+    dnn_hidden_units=[100, 50])
 ```
 
 ## Training and Evaluating The Model
@@ -215,26 +215,18 @@ Before we train the model, let's read in the Census dataset as we did in the
 After reading in the data, you can train and evaluate the model:
 
 ```python
-# Set up input function generators for the train and test data files.
-train_input_fn = input_fn(
-    data_file=FLAGS.train_data,
-    num_epochs=FLAGS.epochs_per_eval,
-    shuffle=True,
-    batch_size=FLAGS.batch_size)
-eval_input_fn = input_fn(
-    data_file=FLAGS.test_data,
-    num_epochs=1,
-    shuffle=False,
-    batch_size=FLAGS.batch_size)
-
 # Train and evaluate the model every `FLAGS.epochs_per_eval` epochs.
 for n in range(FLAGS.train_epochs // FLAGS.epochs_per_eval):
-  model.train(input_fn=train_input_fn)
-  results = model.evaluate(input_fn=eval_input_fn)
+  model.train(input_fn=lambda: input_fn(
+      FLAGS.train_data, FLAGS.epochs_per_eval, True, FLAGS.batch_size))
+
+  results = model.evaluate(input_fn=lambda: input_fn(
+      FLAGS.test_data, 1, False, FLAGS.batch_size))
 
   # Display evaluation metrics
   print('Results at epoch', (n + 1) * FLAGS.epochs_per_eval)
   print('-' * 30)
+
   for key in sorted(results):
     print('%s: %s' % (key, results[key]))
 ```
diff --git a/tensorflow/go/op/wrappers.go b/tensorflow/go/op/wrappers.go
index 385248d403ac66bb0639abdfea189412d7aa3414..4e5d17f76fd990a9531c9ed878defa46d0b2e500 100644
--- a/tensorflow/go/op/wrappers.go
+++ b/tensorflow/go/op/wrappers.go
@@ -3983,6 +3983,41 @@ func TensorArrayWriteV2(scope *Scope, handle tf.Output, index tf.Output, value t
 	return op.Output(0)
 }
 
+// Identity op for gradient debugging.
+//
+// This op is hidden from public in Python. It is used by TensorFlow Debugger to
+// register gradient tensors for gradient debugging.
+func DebugGradientIdentity(scope *Scope, input tf.Output) (output tf.Output) {
+	if scope.Err() != nil {
+		return
+	}
+	opspec := tf.OpSpec{
+		Type: "DebugGradientIdentity",
+		Input: []tf.Input{
+			input,
+		},
+	}
+	op := scope.AddOperation(opspec)
+	return op.Output(0)
+}
+
+// Deprecated. Use TensorArrayGradV3
+func TensorArrayGradV2(scope *Scope, handle tf.Output, flow_in tf.Output, source string) (grad_handle tf.Output) {
+	if scope.Err() != nil {
+		return
+	}
+	attrs := map[string]interface{}{"source": source}
+	opspec := tf.OpSpec{
+		Type: "TensorArrayGradV2",
+		Input: []tf.Input{
+			handle, flow_in,
+		},
+		Attrs: attrs,
+	}
+	op := scope.AddOperation(opspec)
+	return op.Output(0)
+}
+
 // Get the current size of the TensorArray.
 //
 // Arguments:
@@ -4516,6 +4551,31 @@ func QueueCloseV2(scope *Scope, handle tf.Output, optional ...QueueCloseV2Attr)
 	return scope.AddOperation(opspec)
 }
 
+// Concatenates tensors along one dimension.
+//
+// Arguments:
+//	values: List of `N` Tensors to concatenate. Their ranks and types must match,
+// and their sizes must match in all dimensions except `concat_dim`.
+//	axis: 0-D.  The dimension along which to concatenate.  Must be in the
+// range [-rank(values), rank(values)).
+//
+// Returns A `Tensor` with the concatenation of values stacked along the
+// `concat_dim` dimension.  This tensor's shape matches that of `values` except
+// in `concat_dim` where it has the sum of the sizes.
+func ConcatV2(scope *Scope, values []tf.Output, axis tf.Output) (output tf.Output) {
+	if scope.Err() != nil {
+		return
+	}
+	opspec := tf.OpSpec{
+		Type: "ConcatV2",
+		Input: []tf.Input{
+			tf.OutputList(values), axis,
+		},
+	}
+	op := scope.AddOperation(opspec)
+	return op.Output(0)
+}
+
 // QueueDequeueUpToV2Attr is an optional argument to QueueDequeueUpToV2.
 type QueueDequeueUpToV2Attr func(optionalAttr)
 
@@ -4932,6 +4992,80 @@ func PriorityQueueV2(scope *Scope, shapes []tf.Shape, optional ...PriorityQueueV
 	return op.Output(0)
 }
 
+// FIFOQueueV2Attr is an optional argument to FIFOQueueV2.
+type FIFOQueueV2Attr func(optionalAttr)
+
+// FIFOQueueV2Shapes sets the optional shapes attribute to value.
+//
+// value: The shape of each component in a value. The length of this attr must
+// be either 0 or the same as the length of component_types. If the length of
+// this attr is 0, the shapes of queue elements are not constrained, and
+// only one element may be dequeued at a time.
+// If not specified, defaults to <>
+//
+// REQUIRES: len(value) >= 0
+func FIFOQueueV2Shapes(value []tf.Shape) FIFOQueueV2Attr {
+	return func(m optionalAttr) {
+		m["shapes"] = value
+	}
+}
+
+// FIFOQueueV2Capacity sets the optional capacity attribute to value.
+//
+// value: The upper bound on the number of elements in this queue.
+// Negative numbers mean no limit.
+// If not specified, defaults to -1
+func FIFOQueueV2Capacity(value int64) FIFOQueueV2Attr {
+	return func(m optionalAttr) {
+		m["capacity"] = value
+	}
+}
+
+// FIFOQueueV2Container sets the optional container attribute to value.
+//
+// value: If non-empty, this queue is placed in the given container.
+// Otherwise, a default container is used.
+// If not specified, defaults to ""
+func FIFOQueueV2Container(value string) FIFOQueueV2Attr {
+	return func(m optionalAttr) {
+		m["container"] = value
+	}
+}
+
+// FIFOQueueV2SharedName sets the optional shared_name attribute to value.
+//
+// value: If non-empty, this queue will be shared under the given name
+// across multiple sessions.
+// If not specified, defaults to ""
+func FIFOQueueV2SharedName(value string) FIFOQueueV2Attr {
+	return func(m optionalAttr) {
+		m["shared_name"] = value
+	}
+}
+
+// A queue that produces elements in first-in first-out order.
+//
+// Arguments:
+//	component_types: The type of each component in a value.
+//
+// Returns The handle to the queue.
+func FIFOQueueV2(scope *Scope, component_types []tf.DataType, optional ...FIFOQueueV2Attr) (handle tf.Output) {
+	if scope.Err() != nil {
+		return
+	}
+	attrs := map[string]interface{}{"component_types": component_types}
+	for _, a := range optional {
+		a(attrs)
+	}
+	opspec := tf.OpSpec{
+		Type: "FIFOQueueV2",
+
+		Attrs: attrs,
+	}
+	op := scope.AddOperation(opspec)
+	return op.Output(0)
+}
+
 // StridedSliceAttr is an optional argument to StridedSlice.
 type StridedSliceAttr func(optionalAttr)
 
@@ -5311,101 +5445,6 @@ func DynamicStitch(scope *Scope, indices []tf.Output, data []tf.Output) (merged
 	return op.Output(0)
 }
 
-// FIFOQueueV2Attr is an optional argument to FIFOQueueV2.
-type FIFOQueueV2Attr func(optionalAttr)
-
-// FIFOQueueV2Shapes sets the optional shapes attribute to value.
-//
-// value: The shape of each component in a value. The length of this attr must
-// be either 0 or the same as the length of component_types. If the length of
-// this attr is 0, the shapes of queue elements are not constrained, and
-// only one element may be dequeued at a time.
-// If not specified, defaults to <>
-//
-// REQUIRES: len(value) >= 0
-func FIFOQueueV2Shapes(value []tf.Shape) FIFOQueueV2Attr {
-	return func(m optionalAttr) {
-		m["shapes"] = value
-	}
-}
-
-// FIFOQueueV2Capacity sets the optional capacity attribute to value.
-//
-// value: The upper bound on the number of elements in this queue.
-// Negative numbers mean no limit.
-// If not specified, defaults to -1
-func FIFOQueueV2Capacity(value int64) FIFOQueueV2Attr {
-	return func(m optionalAttr) {
-		m["capacity"] = value
-	}
-}
-
-// FIFOQueueV2Container sets the optional container attribute to value.
-//
-// value: If non-empty, this queue is placed in the given container.
-// Otherwise, a default container is used.
-// If not specified, defaults to ""
-func FIFOQueueV2Container(value string) FIFOQueueV2Attr {
-	return func(m optionalAttr) {
-		m["container"] = value
-	}
-}
-
-// FIFOQueueV2SharedName sets the optional shared_name attribute to value.
-//
-// value: If non-empty, this queue will be shared under the given name
-// across multiple sessions.
-// If not specified, defaults to ""
-func FIFOQueueV2SharedName(value string) FIFOQueueV2Attr {
-	return func(m optionalAttr) {
-		m["shared_name"] = value
-	}
-}
-
-// A queue that produces elements in first-in first-out order.
-//
-// Arguments:
-//	component_types: The type of each component in a value.
-//
-// Returns The handle to the queue.
-func FIFOQueueV2(scope *Scope, component_types []tf.DataType, optional ...FIFOQueueV2Attr) (handle tf.Output) {
-	if scope.Err() != nil {
-		return
-	}
-	attrs := map[string]interface{}{"component_types": component_types}
-	for _, a := range optional {
-		a(attrs)
-	}
-	opspec := tf.OpSpec{
-		Type: "FIFOQueueV2",
-
-		Attrs: attrs,
-	}
-	op := scope.AddOperation(opspec)
-	return op.Output(0)
-}
-
-// Converts the given `resource_handle` representing an iterator to a variant tensor.
-//
-// Arguments:
-//	resource_handle: A handle to an iterator resource.
-//
-// Returns A variant tensor storing the state of the iterator contained in the
-// resource.
-func SerializeIterator(scope *Scope, resource_handle tf.Output) (serialized tf.Output) {
-	if scope.Err() != nil {
-		return
-	}
-	opspec := tf.OpSpec{
-		Type: "SerializeIterator",
-		Input: []tf.Input{
-			resource_handle,
-		},
-	}
-	op := scope.AddOperation(opspec)
-	return op.Output(0)
-}
-
 // Return a tensor with the same shape and contents as the input tensor or value.
 func Identity(scope *Scope, input tf.Output) (output tf.Output) {
 	if scope.Err() != nil {
@@ -5537,39 +5576,6 @@ func IteratorToStringHandle(scope *Scope, resource_handle tf.Output) (string_han
 	return op.Output(0)
 }
 
-// Outputs the single element from the given dataset.
-//
-// Arguments:
-//	dataset: A handle to a dataset that contains a single element.
-//
-//
-//
-// Returns The components of the single element of `input`.
-func DatasetToSingleElement(scope *Scope, dataset tf.Output, output_types []tf.DataType, output_shapes []tf.Shape) (components []tf.Output) {
-	if scope.Err() != nil {
-		return
-	}
-	attrs := map[string]interface{}{"output_types": output_types, "output_shapes": output_shapes}
-	opspec := tf.OpSpec{
-		Type: "DatasetToSingleElement",
-		Input: []tf.Input{
-			dataset,
-		},
-		Attrs: attrs,
-	}
-	op := scope.AddOperation(opspec)
-	if scope.Err() != nil {
-		return
-	}
-	var idx int
-	var err error
-	if components, idx, err = makeOutputList(op, idx, "components"); err != nil {
-		scope.UpdateErr("DatasetToSingleElement", err)
-		return
-	}
-	return components
-}
-
 // Gets the next output from the given iterator.
 func IteratorGetNext(scope *Scope, iterator tf.Output, output_types []tf.DataType, output_shapes []tf.Shape) (components []tf.Output) {
 	if scope.Err() != nil {
@@ -5690,30 +5696,6 @@ func FixedLengthRecordDataset(scope *Scope, filenames tf.Output, header_bytes tf
 	return op.Output(0)
 }
 
-// Creates a dataset that executes a SQL query and emits rows of the result set.
-//
-// Arguments:
-//	driver_name: The database type. Currently, the only supported type is 'sqlite'.
-//	data_source_name: A connection string to connect to the database.
-//	query: A SQL query to execute.
-//
-//
-func SqlDataset(scope *Scope, driver_name tf.Output, data_source_name tf.Output, query tf.Output, output_types []tf.DataType, output_shapes []tf.Shape) (handle tf.Output) {
-	if scope.Err() != nil {
-		return
-	}
-	attrs := map[string]interface{}{"output_types": output_types, "output_shapes": output_shapes}
-	opspec := tf.OpSpec{
-		Type: "SqlDataset",
-		Input: []tf.Input{
-			driver_name, data_source_name, query,
-		},
-		Attrs: attrs,
-	}
-	op := scope.AddOperation(opspec)
-	return op.Output(0)
-}
-
 // PlaceholderAttr is an optional argument to Placeholder.
 type PlaceholderAttr func(optionalAttr)
 
@@ -5784,68 +5766,6 @@ func CacheDataset(scope *Scope, input_dataset tf.Output, filename tf.Output, out
 	return op.Output(0)
 }
 
-// Identity op for gradient debugging.
-//
-// This op is hidden from public in Python. It is used by TensorFlow Debugger to
-// register gradient tensors for gradient debugging.
-func DebugGradientIdentity(scope *Scope, input tf.Output) (output tf.Output) {
-	if scope.Err() != nil {
-		return
-	}
-	opspec := tf.OpSpec{
-		Type: "DebugGradientIdentity",
-		Input: []tf.Input{
-			input,
-		},
-	}
-	op := scope.AddOperation(opspec)
-	return op.Output(0)
-}
-
-// Deprecated. Use TensorArrayGradV3
-func TensorArrayGradV2(scope *Scope, handle tf.Output, flow_in tf.Output, source string) (grad_handle tf.Output) {
-	if scope.Err() != nil {
-		return
-	}
-	attrs := map[string]interface{}{"source": source}
-	opspec := tf.OpSpec{
-		Type: "TensorArrayGradV2",
-		Input: []tf.Input{
-			handle, flow_in,
-		},
-		Attrs: attrs,
-	}
-	op := scope.AddOperation(opspec)
-	return op.Output(0)
-}
-
-// Creates a dataset that yields a SparseTensor for each element of the input.
-//
-// Arguments:
-//	input_dataset: A handle to an input dataset. Must have a single component.
-//	batch_size: A scalar representing the number of elements to accumulate in a
-// batch.
-//	row_shape: A vector representing the dense shape of each row in the produced
-// SparseTensor. The shape may be partially specified, using `-1` to indicate
-// that a particular dimension should use the maximum size of all batch elements.
-//
-//
-func DenseToSparseBatchDataset(scope *Scope, input_dataset tf.Output, batch_size tf.Output, row_shape tf.Output, output_types []tf.DataType, output_shapes []tf.Shape) (handle tf.Output) {
-	if scope.Err() != nil {
-		return
-	}
-	attrs := map[string]interface{}{"output_types": output_types, "output_shapes": output_shapes}
-	opspec := tf.OpSpec{
-		Type: "DenseToSparseBatchDataset",
-		Input: []tf.Input{
-			input_dataset, batch_size, row_shape,
-		},
-		Attrs: attrs,
-	}
-	op := scope.AddOperation(opspec)
-	return op.Output(0)
-}
-
 // Creates a dataset that batches and pads `batch_size` elements from the input.
 //
 // Arguments:
@@ -5906,69 +5826,6 @@ func TensorArrayConcatV2(scope *Scope, handle tf.Output, flow_in tf.Output, dtyp
 	return op.Output(0), op.Output(1)
 }
 
-// Converts the given variant tensor to an iterator and stores it in the given resource.
-//
-// Arguments:
-//	resource_handle: A handle to an iterator resource.
-//	serialized: A variant tensor storing the state of the iterator contained in the
-// resource.
-//
-// Returns the created operation.
-func DeserializeIterator(scope *Scope, resource_handle tf.Output, serialized tf.Output) (o *tf.Operation) {
-	if scope.Err() != nil {
-		return
-	}
-	opspec := tf.OpSpec{
-		Type: "DeserializeIterator",
-		Input: []tf.Input{
-			resource_handle, serialized,
-		},
-	}
-	return scope.AddOperation(opspec)
-}
-
-// Concatenates tensors along one dimension.
-//
-// Arguments:
-//	values: List of `N` Tensors to concatenate. Their ranks and types must match,
-// and their sizes must match in all dimensions except `concat_dim`.
-//	axis: 0-D.  The dimension along which to concatenate.  Must be in the
-// range [-rank(values), rank(values)).
-//
-// Returns A `Tensor` with the concatenation of values stacked along the
-// `concat_dim` dimension.  This tensor's shape matches that of `values` except
-// in `concat_dim` where it has the sum of the sizes.
-func ConcatV2(scope *Scope, values []tf.Output, axis tf.Output) (output tf.Output) {
-	if scope.Err() != nil {
-		return
-	}
-	opspec := tf.OpSpec{
-		Type: "ConcatV2",
-		Input: []tf.Input{
-			tf.OutputList(values), axis,
-		},
-	}
-	op := scope.AddOperation(opspec)
-	return op.Output(0)
-}
-
-// Creates a dataset that contains the elements of `input_dataset` ignoring errors.
-func IgnoreErrorsDataset(scope *Scope, input_dataset tf.Output, output_types []tf.DataType, output_shapes []tf.Shape) (handle tf.Output) {
-	if scope.Err() != nil {
-		return
-	}
-	attrs := map[string]interface{}{"output_types": output_types, "output_shapes": output_shapes}
-	opspec := tf.OpSpec{
-		Type: "IgnoreErrorsDataset",
-		Input: []tf.Input{
-			input_dataset,
-		},
-		Attrs: attrs,
-	}
-	op := scope.AddOperation(opspec)
-	return op.Output(0)
-}
-
 // Creates a dataset that concatenates `input_dataset` with `another_dataset`.
 func ConcatenateDataset(scope *Scope, input_dataset tf.Output, another_dataset tf.Output, output_types []tf.DataType, output_shapes []tf.Shape) (handle tf.Output) {
 	if scope.Err() != nil {
@@ -7996,6 +7853,41 @@ func Cholesky(scope *Scope, input tf.Output) (output tf.Output) {
 	return op.Output(0)
 }
 
+// Computes the matrix exponential of one or more square matrices:
+//
+// exp(A) = \sum_{n=0}^\infty A^n/n!
+//
+// The exponential is computed using a combination of the scaling and squaring
+// method and the Pade approximation. Details can be founds in:
+// Nicholas J. Higham, "The scaling and squaring method for the matrix exponential
+// revisited," SIAM J. Matrix Anal. Applic., 26:1179-1193, 2005.
+//
+// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+// form square matrices. The output is a tensor of the same shape as the input
+// containing the exponential for all input submatrices `[..., :, :]`.
+//
+// Arguments:
+//	input: Shape is `[..., M, M]`.
+//
+// Returns Shape is `[..., M, M]`.
+//
+// @compatibility(scipy)
+// Equivalent to scipy.linalg.expm
+// @end_compatibility
+func MatrixExponential(scope *Scope, input tf.Output) (output tf.Output) {
+	if scope.Err() != nil {
+		return
+	}
+	opspec := tf.OpSpec{
+		Type: "MatrixExponential",
+		Input: []tf.Input{
+			input,
+		},
+	}
+	op := scope.AddOperation(opspec)
+	return op.Output(0)
+}
+
 // MaxPool3DGradGradAttr is an optional argument to MaxPool3DGradGrad.
 type MaxPool3DGradGradAttr func(optionalAttr)
 
@@ -18445,12 +18337,32 @@ func ResourceScatterUpdate(scope *Scope, resource tf.Output, indices tf.Output,
 	return scope.AddOperation(opspec)
 }
 
+// GenerateVocabRemappingAttr is an optional argument to GenerateVocabRemapping.
+type GenerateVocabRemappingAttr func(optionalAttr)
+
+// GenerateVocabRemappingOldVocabSize sets the optional old_vocab_size attribute to value.
+//
+// value: Number of entries in the old vocab file to consider.  If -1,
+// use the entire old vocabulary.
+// If not specified, defaults to -1
+//
+// REQUIRES: value >= -1
+func GenerateVocabRemappingOldVocabSize(value int64) GenerateVocabRemappingAttr {
+	return func(m optionalAttr) {
+		m["old_vocab_size"] = value
+	}
+}
+
 // Given a path to new and old vocabulary files, returns a remapping Tensor of
 //
 // length `num_new_vocab`, where `remapping[i]` contains the row number in the old
 // vocabulary that corresponds to row `i` in the new vocabulary (starting at line
 // `new_vocab_offset` and up to `num_new_vocab` entities), or `-1` if entry `i`
-// in the new vocabulary is not in the old vocabulary.  `num_vocab_offset` enables
+// in the new vocabulary is not in the old vocabulary.  The old vocabulary is
+// constrained to the first `old_vocab_size` entries if `old_vocab_size` is not the
+// default value of -1.
+//
+// `num_vocab_offset` enables
 // use in the partitioned variable case, and should generally be set through
 // examining partitioning info.  The format of the files should be a text file,
 // with each line containing a single entity within the vocabulary.
@@ -18481,11 +18393,14 @@ func ResourceScatterUpdate(scope *Scope, resource tf.Output, indices tf.Output,
 // Returns A Tensor of length num_new_vocab where the element at index i
 // is equal to the old ID that maps to the new ID i.  This element is -1 for any
 // new ID that is not found in the old vocabulary.Number of new vocab entries found in old vocab.
-func GenerateVocabRemapping(scope *Scope, new_vocab_file tf.Output, old_vocab_file tf.Output, new_vocab_offset int64, num_new_vocab int64) (remapping tf.Output, num_present tf.Output) {
+func GenerateVocabRemapping(scope *Scope, new_vocab_file tf.Output, old_vocab_file tf.Output, new_vocab_offset int64, num_new_vocab int64, optional ...GenerateVocabRemappingAttr) (remapping tf.Output, num_present tf.Output) {
 	if scope.Err() != nil {
 		return
 	}
 	attrs := map[string]interface{}{"new_vocab_offset": new_vocab_offset, "num_new_vocab": num_new_vocab}
+	for _, a := range optional {
+		a(attrs)
+	}
 	opspec := tf.OpSpec{
 		Type: "GenerateVocabRemapping",
 		Input: []tf.Input{
diff --git a/tensorflow/python/BUILD b/tensorflow/python/BUILD
index 02e88f4888f7813162894c24770b932b49cd454a..76477384de1f20f5e93ed291c84203b48ad24b89 100644
--- a/tensorflow/python/BUILD
+++ b/tensorflow/python/BUILD
@@ -130,6 +130,7 @@ py_library(
         ":pywrap_tensorflow",
         ":util",
         "//tensorflow/core:protos_all_py",
+        "@absl_py//absl/flags",
         "@six_archive//:six",
     ],
 )
@@ -1544,6 +1545,7 @@ py_library(
         ":platform",
         ":sparse_tensor",
         ":tensor_array_ops",
+        ":tf_should_use",
         ":util",
         "//tensorflow/core:protos_all_py",
         "@six_archive//:six",
@@ -1833,6 +1835,7 @@ py_library(
         ":control_flow_ops",
         ":framework_for_generated_wrappers",
         ":math_ops",
+        ":tf_should_use",
     ],
 )
 
@@ -2307,7 +2310,7 @@ py_library(
         ":math_ops",
         ":tensor_shape",
         ":tensor_util",
-        ":util",
+        ":tf_should_use",
         "//tensorflow/python/eager:context",
     ],
 )
@@ -2344,6 +2347,7 @@ py_library(
         ":math_ops",
         ":state_ops",
         ":tensor_shape",
+        ":tf_should_use",
         ":util",
         "//tensorflow/core:protos_all_py",
         "//tensorflow/python/eager:context",
@@ -2727,6 +2731,7 @@ py_library(
         ["util/**/*.py"],
         exclude = [
             "util/example_parser*",
+            "util/tf_should_use.py",
             "util/**/*_test.py",
         ],
     ),
@@ -2789,6 +2794,17 @@ py_test(
     ],
 )
 
+py_library(
+    name = "tf_should_use",
+    srcs = ["util/tf_should_use.py"],
+    srcs_version = "PY2AND3",
+    deps = [
+        ":util",
+        "//tensorflow/python/eager:context",
+        "@six_archive//:six",
+    ],
+)
+
 py_test(
     name = "tf_should_use_test",
     size = "small",
@@ -2796,7 +2812,7 @@ py_test(
     srcs_version = "PY2AND3",
     deps = [
         ":client_testlib",
-        ":util",
+        ":tf_should_use",
     ],
 )
 
@@ -4350,8 +4366,16 @@ cuda_py_test(
         ":client_testlib",
         ":framework_for_generated_wrappers",
         ":array_ops",
+        ":constant_op",
+        ":dtypes",
+        ":functional_ops",
+        ":layers",
+        ":math_ops",
         ":nn",
+        ":ops",
         ":random_ops",
+        ":tf_optimizer",
+        ":training",
         "//third_party/py/numpy",
         "//tensorflow/core:protos_all_py",
     ],
diff --git a/tensorflow/python/debug/lib/debug_data.py b/tensorflow/python/debug/lib/debug_data.py
index 4d7332453055f4bd799a904724a2b93170a43153..c4b13a1045dac4966b0e841155a2932216881d34 100644
--- a/tensorflow/python/debug/lib/debug_data.py
+++ b/tensorflow/python/debug/lib/debug_data.py
@@ -558,8 +558,7 @@ class DebugDumpDir(object):
     for root, _, files in gfile.Walk(device_root):
       for f in files:
         if _is_graph_file(f):
-          self._dump_graph_file_paths[device_name] = os.path.join(
-              device_root, root, f)
+          self._dump_graph_file_paths[device_name] = os.path.join(root, f)
         else:
           datum = self._dump_file_name_to_datum(root, f)
           self._dump_tensor_data[device_name].append(datum)
diff --git a/tensorflow/python/eager/BUILD b/tensorflow/python/eager/BUILD
index f5b946ec263c40bd62261297ef55ffa52cb2c042..bcd1e1d0dca9c952e71ac734cc74ef803ba5becb 100644
--- a/tensorflow/python/eager/BUILD
+++ b/tensorflow/python/eager/BUILD
@@ -3,6 +3,10 @@ licenses(["notice"])  # Apache 2.0
 load("//tensorflow:tensorflow.bzl", "py_test")
 load("//tensorflow:tensorflow.bzl", "cuda_py_test")
 load("//tensorflow:tensorflow.bzl", "tf_cc_binary")
+load(
+    "//tensorflow/tools/test:performance.bzl",
+    "tf_py_logged_benchmark",
+)
 
 cc_library(
     name = "pywrap_tfe_lib",
@@ -356,22 +360,26 @@ py_library(
     ],
 )
 
-py_test(
+cuda_py_test(
     name = "benchmarks_test",
     srcs = ["benchmarks_test.py"],
-    srcs_version = "PY2AND3",
-    deps = [
+    additional_deps = [
         ":backprop",
         ":context",
         ":function",
         ":test",
+        "//third_party/py/numpy",
         "//tensorflow/python:math_ops",
         "//tensorflow/python:pywrap_tensorflow",
         "//tensorflow/python:random_ops",
-        "//third_party/py/numpy",
     ],
 )
 
+tf_py_logged_benchmark(
+    name = "benchmarks",
+    target = "//tensorflow/python/eager:benchmarks_test",
+)
+
 py_test(
     name = "tape_test",
     srcs = ["tape_test.py"],
diff --git a/tensorflow/python/eager/backprop.py b/tensorflow/python/eager/backprop.py
index 6f7f2117be6ffaa426b1ff59c18140c0cc9e552a..86b3776b8c5ed5b84d9a088abcb7853477f95089 100644
--- a/tensorflow/python/eager/backprop.py
+++ b/tensorflow/python/eager/backprop.py
@@ -657,14 +657,14 @@ def make_vjp(f, params=None):
       for i in parameter_positions:
         sources.append(args[i])
         tape.watch(args[i])
-        result = f(*args)
-        if result is None:
-          raise ValueError("Cannot differentiate a function that returns None; "
-                           "did you forget to return a value from {}?".format(
-                               f.__name__))
-        flat_result = nest.flatten(result)
-        flat_result = [gen_array_ops.identity(x) for x in flat_result]
-        result = nest.pack_sequence_as(result, flat_result)
+      result = f(*args)
+      if result is None:
+        raise ValueError("Cannot differentiate a function that returns None; "
+                         "did you forget to return a value from {}?".format(
+                             f.__name__))
+      flat_result = nest.flatten(result)
+      flat_result = [gen_array_ops.identity(x) for x in flat_result]
+      result = nest.pack_sequence_as(result, flat_result)
     finally:
       t = tape.pop_tape()
     def vjp(dy=None):
diff --git a/tensorflow/python/eager/benchmarks_test.py b/tensorflow/python/eager/benchmarks_test.py
index 1a2f99fe9e7de73aadee46f02c068cf4dc5697ed..26a70a617d5b1b1af7397a03835f51f10da1cc57 100644
--- a/tensorflow/python/eager/benchmarks_test.py
+++ b/tensorflow/python/eager/benchmarks_test.py
@@ -12,21 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Benchmarks for low-level eager execution primitives.
+r"""Benchmarks for low-level eager execution primitives.
 
-Packaged as a test to ensure that this code is exercised by continuous
-integration tests. To get numbers:
+To run CPU benchmarks:
+  bazel run -c opt benchmarks_test -- --benchmarks=.
 
-  bazel build -c opt :benchmarks_test &&
-  ./bazel-bin/tensorflow/python/eager/benchmarks_test --iters=0
+To run GPU benchmarks:
+  bazel run --config=cuda -c opt --copt="-mavx" benchmarks_test -- \
+    --benchmarks=.
 """
 from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
-import argparse
-import contextlib
-import sys
 import time
 
 import numpy as np
@@ -39,161 +37,274 @@ from tensorflow.python.eager import function
 from tensorflow.python.eager import test
 from tensorflow.python.framework import dtypes
 from tensorflow.python.framework import ops
-from tensorflow.python.framework import test_util
 from tensorflow.python.ops import gen_math_ops
 from tensorflow.python.ops import math_ops
 from tensorflow.python.ops import random_ops
 
-FLAGS = None
-
-
-@contextlib.contextmanager
-def timer(label, iters=30000):
-  start = time.time()
-  yield xrange(iters)
-  end = time.time()
-  t = (end - start) * 1e6 / iters
-  print("%-40s took %.2fus (%d iterations)" % (label, t, iters))
-
-
-def benchmark_create_tensor(n):
-  """Benchmark overheads of creating a Tensor object."""
-
-  def label(s):
-    return "{:20s}".format(s)
-
-  with timer(label("np.array([[3.0]])"), iters=n) as iters:
-    for _ in iters:
-      np.array([[3.0]])
-
-  ctx = context.context()
-  handle = ctx._handle
-  device = ctx.device_name
-  # May be warmup GPU.
-  ops.EagerTensor([[3.0]], context=handle, device=device)
-
-  # float32
-  dtype = dtypes.float32.as_datatype_enum
-  three = [[3.0]]
-  with timer(label("EagerTensor([[3.0]])"), iters=n) as iters:
-    for _ in iters:
-      ops.EagerTensor(three, context=handle, device=device, dtype=dtype)
-
-  np_3 = np.array([[3.0]], dtype=np.float32)
-  with timer(label("EagerTensor(np.array([[3.0]]))"), iters=n) as iters:
-    for _ in iters:
-      ops.EagerTensor(np_3, context=handle, device=device, dtype=dtype)
-
-  # int32.
-  # This is interesting since int32 will be kept on host memory for the GPU
-  # case.
-  dtype = dtypes.int32.as_datatype_enum
-  three = [[3]]
-  with timer(label("EagerTensor([[3]])"), iters=n) as iters:
-    for _ in iters:
-      ops.EagerTensor(three, context=handle, device=device, dtype=dtype)
-
-  np_3 = np.array([[3]], dtype=np.int32)
-  with timer(label("EagerTensor(np.array([[3]]))"), iters=n) as iters:
-    for _ in iters:
-      ops.EagerTensor(np_3, context=handle, device=device, dtype=dtype)
-
-
-def benchmark_matmul(shape, n, use_gpu=False):
-  """Benchmark for matrix multiplication using tf.matmul."""
-  transpose_b = (shape[0] != shape[1])
-  m = random_ops.random_uniform(shape)
-  if use_gpu:
-    m = m.gpu()
-    # Warm up the GPU - the very first kernel invocation
-    # seems to require a bunch of setup.
-    math_ops.matmul(m, m, transpose_b=transpose_b)
-
-  def label(s):
-    return "MatMul {}: {:30s}".format(shape, s)
-
-  if not use_gpu:
-    a = m.cpu().numpy()
-    b = a.T if transpose_b else a
-    with timer(label("np.dot"), iters=n) as iters:
-      for _ in iters:
-        np.dot(a, b)
 
-  with timer(label("tf.matmul"), iters=n) as iters:
-    for _ in iters:
-      math_ops.matmul(m, m, transpose_b=transpose_b)
+CPU = "/device:CPU:0"
+GPU = "/device:GPU:0"
+
+
+class MicroBenchmarks(test.Benchmark):
+
+  def __init__(self):
+    # used for multiply benchmarks
+    self._m_2 = random_ops.random_uniform([2])
+
+    # used for matmul benchmarks
+    self._m_2_by_2 = random_ops.random_uniform((2, 2))
+    self._m_100_by_784 = random_ops.random_uniform((100, 784))
+    self._num_iters_2_by_2 = 30000
+    self._num_iters_100_by_784 = 1000
+
+  def _run(self, func, num_iters):
+    # call func to maybe warm up the GPU
+    func()
+    start = time.time()
+    for _ in xrange(num_iters):
+      func()
+    end = time.time()
+    mean_us = (end - start) * 1e6 / num_iters
+    self.report_benchmark(iters=num_iters, wall_time=mean_us)
+
+  def benchmark_create_np_array(self):
+    func = lambda: np.array([3.0])
+    self._run(func, 30000)
+
+  def _benchmark_create_tensor(self, value, dtype, device):
+    """Benchmark overheads of creating a Tensor object."""
+    ctx = context.context()
+    handle = ctx._handle
+    if device == GPU:
+      # Warmup the GPU
+      ops.EagerTensor(value, context=handle, device=device)
+
+    def func():
+      ops.EagerTensor(value, context=handle, device=device, dtype=dtype)
+    self._run(func, 30000)
+
+  def benchmark_create_float_tensor_from_list_CPU(self):
+    self._benchmark_create_tensor([[3.0]], dtypes.float32.as_datatype_enum, CPU)
+
+  def benchmark_create_float_tensor_from_np_array_CPU(self):
+    self._benchmark_create_tensor(
+        np.array([[3.0]], dtype=np.float32), dtypes.float32.as_datatype_enum,
+        CPU)
+
+  def benchmark_create_int32_tensor_from_list_CPU(self):
+    self._benchmark_create_tensor([[3]], dtypes.int32.as_datatype_enum, CPU)
+
+  def benchmark_create_int32_tensor_from_np_array_CPU(self):
+    self._benchmark_create_tensor(
+        np.array([[3]], dtype=np.int32), dtypes.int32.as_datatype_enum, CPU)
+
+  def benchmark_create_float_tensor_from_list_GPU(self):
+    if not context.num_gpus():
+      return
+    self._benchmark_create_tensor([[3.0]], dtypes.float32.as_datatype_enum, GPU)
+
+  def benchmark_create_float_tensor_from_np_array_GPU(self):
+    if not context.num_gpus():
+      return
+    self._benchmark_create_tensor(
+        np.array([[3.0]], dtype=np.float32), dtypes.float32.as_datatype_enum,
+        GPU)
+
+  def benchmark_create_int32_tensor_from_list_GPU(self):
+    # int32's are kept on host memory even when executing on GPU.
+    if not context.num_gpus():
+      return
+    self._benchmark_create_tensor([[3]], dtypes.int32.as_datatype_enum, GPU)
+
+  def benchmark_create_int32_tensor_from_np_array_GPU(self):
+    # int32's are kept on host memory even when executing on GPU.
+    if not context.num_gpus():
+      return
+    self._benchmark_create_tensor(
+        np.array([[3]], dtype=np.int32), dtypes.int32.as_datatype_enum, GPU)
+
+  def _benchmark_np_multiply(self, m, num_iters):
+    a = m.cpu().numpy()
+    func = lambda: a * a
+    self._run(func, num_iters)
 
-  with timer(label("gen_math_ops.mat_mul"), iters=n) as iters:
-    for _ in iters:
-      gen_math_ops._mat_mul(m, m, transpose_b=transpose_b)
+  def _benchmark_tf_multiply(self, m, num_iters):
+    func = lambda: m * m
+    self._run(func, num_iters)
 
-  inputs = [m, m]
-  # pylint: disable=protected-access
-  ctx_handle = context.context()._handle
-  # pylint: enable=protected-access
-  attrs = ("transpose_a", False, "transpose_b", transpose_b, "T",
-           m.dtype.as_datatype_enum)
-  with timer(label("TFE_Py_Execute"), iters=n) as iters:
-    for _ in iters:
-      pywrap_tensorflow.TFE_Py_Execute(ctx_handle, None, "MatMul",
-                                       inputs, attrs, 1)
-
-  f = function.defun(math_ops.matmul)
-  with timer(label("defun(tf.matmul)"), iters=n) as iters:
-    for _ in iters:
-      f(m, m, transpose_b=transpose_b)
-
-
-def benchmark_multiply(shape, n, use_gpu=False):
-  m = random_ops.random_uniform(shape)
-  if use_gpu:
-    m = m.gpu()
-    # Warm up the GPU - the very first kernel invocation
-    # seems to require a bunch of setup.
-    _ = m * m
-
-  def label(s):
-    return "Multiply {}: {:30s}".format(shape, s)
-
-  if not use_gpu:
-    a = m.cpu().numpy()
-    with timer(label("np.multiply"), iters=n) as iters:
-      for _ in iters:
-        _ = a * a
+  def benchmark_np_multiply(self):
+    self._benchmark_np_multiply(self._m_2, 30000)
 
-  with timer(label("tf.multiply"), iters=n) as iters:
-    for _ in iters:
-      _ = m * m
+  def benchmark_tf_multiply_CPU(self):
+    with context.device(CPU):
+      m = self._m_2.cpu()
+      self._benchmark_tf_multiply(m, 30000)
 
+  def benchmark_tf_multiply_GPU(self):
+    if not context.num_gpus():
+      return
+    with context.device(GPU):
+      m = self._m_2.gpu()
+      self._benchmark_tf_multiply(m, 30000)
 
-class BenchmarksTest(test_util.TensorFlowTestCase):
+  def _benchmark_np_matmul(self, m, transpose_b, num_iters):
+    a = m.cpu().numpy()
+    b = a.T if transpose_b else a
+    func = lambda: np.dot(a, b)
+    self._run(func, num_iters)
 
-  def testBenchmarks(self):
-    # This isn't actually a test, but benchmarks packaged as a test
-    # so that continuous integration runs catch any breakages.
-    print(context.context())
-    benchmark_create_tensor(FLAGS.iters or 30000)
-    benchmark_matmul([2, 2], FLAGS.iters or 30000)
-    benchmark_matmul([100, 28 * 28], FLAGS.iters or 1000)
-    benchmark_multiply([2], FLAGS.iters or 30000)
+  def _benchmark_tf_matmul(self, m, transpose_b, num_iters):
+    func = lambda: math_ops.matmul(m, m, transpose_b=transpose_b)
+    self._run(func, num_iters)
 
-    if context.context().num_gpus() > 0:
-      print("---- RUNNING ON GPU NOW ----")
-      with context.device("/device:GPU:0"):
-        benchmark_create_tensor(FLAGS.iters or 30000)
-      benchmark_matmul([2, 2], FLAGS.iters or 30000, use_gpu=True)
-      benchmark_matmul([100, 28 * 28], FLAGS.iters or 1000, use_gpu=True)
-      benchmark_multiply([2], FLAGS.iters or 30000, use_gpu=True)
+  def _benchmark_gen_math_ops_matmul(self, m, transpose_b, num_iters):
+    def func():
+      gen_math_ops._mat_mul(m, m, transpose_b=transpose_b)
+    self._run(func, num_iters)
+
+  def _benchmark_tfe_py_execute_matmul(self, m, transpose_b, num_iters):
+    inputs = [m, m]
+    # pylint: disable=protected-access
+    ctx_handle = context.context()._handle
+    # pylint: enable=protected-access
+    attrs = ("transpose_a", False, "transpose_b", transpose_b, "T",
+             m.dtype.as_datatype_enum)
+    def func():
+      pywrap_tensorflow.TFE_Py_Execute(ctx_handle, None, "MatMul", inputs,
+                                       attrs, 1)
+
+    self._run(func, num_iters)
+
+  def _benchmark_defun_matmul(self, m, transpose_b, num_iters):
+    f = function.defun(math_ops.matmul)
+    func = lambda: f(m, m, transpose_b)
+    self._run(func, num_iters)
+
+  # Benchmarks for A^2, A of dimension 2 by 2.
+  def benchmark_np_matmul_2_by_2(self):
+    self._benchmark_np_matmul(
+        self._m_2_by_2, transpose_b=False, num_iters=self._num_iters_2_by_2)
+
+  def benchmark_tf_matmul_2_by_2_CPU(self):
+    with context.device(CPU):
+      m = self._m_2_by_2.cpu()
+      self._benchmark_tf_matmul(
+          m, transpose_b=False, num_iters=self._num_iters_2_by_2)
+
+  def benchmark_gen_math_ops_matmul_2_by_2_CPU(self):
+    with context.device(CPU):
+      m = self._m_2_by_2.cpu()
+      self._benchmark_gen_math_ops_matmul(
+          m, transpose_b=False, num_iters=self._num_iters_2_by_2)
+
+  def benchmark_tfe_py_execute_matmul_2_by_2_CPU(self):
+    with context.device(CPU):
+      m = self._m_2_by_2.cpu()
+      self._benchmark_tfe_py_execute_matmul(
+          m, transpose_b=False, num_iters=self._num_iters_2_by_2)
+
+  def benchmark_defun_matmul_2_by_2_CPU(self):
+    with context.device(CPU):
+      m = self._m_2_by_2.cpu()
+      self._benchmark_defun_matmul(
+          m, transpose_b=False, num_iters=self._num_iters_2_by_2)
+
+  def benchmark_tf_matmul_2_by_2_GPU(self):
+    if not context.num_gpus():
+      return
+    with context.device(GPU):
+      m = self._m_2_by_2.gpu()
+      self._benchmark_tf_matmul(
+          m, transpose_b=False, num_iters=self._num_iters_2_by_2)
+
+  def benchmark_gen_math_ops_matmul_2_by_2_GPU(self):
+    if not context.num_gpus():
+      return
+    with context.device(GPU):
+      m = self._m_2_by_2.gpu()
+      self._benchmark_gen_math_ops_matmul(
+          m, transpose_b=False, num_iters=self._num_iters_2_by_2)
+
+  def benchmark_tfe_py_execute_matmul_2_by_2_GPU(self):
+    if not context.num_gpus():
+      return
+    with context.device(GPU):
+      m = self._m_2_by_2.gpu()
+      self._benchmark_tfe_py_execute_matmul(
+          m, transpose_b=False, num_iters=self._num_iters_2_by_2)
+
+  def benchmark_defun_matmul_2_by_2_GPU(self):
+    if not context.num_gpus():
+      return
+    with context.device(GPU):
+      m = self._m_2_by_2.gpu()
+      self._benchmark_defun_matmul(
+          m, transpose_b=False, num_iters=self._num_iters_2_by_2)
+
+  # Benchmarks for AA.T, A of dimension 100 by 784.
+  def benchmark_np_matmul_100_by_784(self):
+    self._benchmark_np_matmul(
+        self._m_100_by_784,
+        transpose_b=True,
+        num_iters=self._num_iters_100_by_784)
+
+  def benchmark_tf_matmul_100_by_784_CPU(self):
+    with context.device(CPU):
+      m = self._m_100_by_784.cpu()
+      self._benchmark_tf_matmul(
+          m, transpose_b=True, num_iters=self._num_iters_100_by_784)
+
+  def benchmark_gen_math_ops_matmul_100_by_784_CPU(self):
+    with context.device(CPU):
+      m = self._m_100_by_784.cpu()
+      self._benchmark_gen_math_ops_matmul(
+          m, transpose_b=True, num_iters=self._num_iters_100_by_784)
+
+  def benchmark_tfe_py_execute_matmul_100_by_784_CPU(self):
+    with context.device(CPU):
+      m = self._m_100_by_784.cpu()
+      self._benchmark_tfe_py_execute_matmul(
+          m, transpose_b=True, num_iters=self._num_iters_100_by_784)
+
+  def benchmark_defun_matmul_100_by_784_CPU(self):
+    with context.device(CPU):
+      m = self._m_100_by_784.cpu()
+      self._benchmark_defun_matmul(
+          m, transpose_b=True, num_iters=self._num_iters_100_by_784)
+
+  def benchmark_tf_matmul_100_by_784_GPU(self):
+    if not context.num_gpus():
+      return
+    with context.device(GPU):
+      m = self._m_100_by_784.gpu()
+      self._benchmark_tf_matmul(
+          m, transpose_b=True, num_iters=self._num_iters_100_by_784)
+
+  def benchmark_gen_math_ops_matmul_100_by_784_GPU(self):
+    if not context.num_gpus():
+      return
+    with context.device(GPU):
+      m = self._m_100_by_784.gpu()
+      self._benchmark_gen_math_ops_matmul(
+          m, transpose_b=True, num_iters=self._num_iters_100_by_784)
+
+  def benchmark_tfe_py_execute_matmul_100_by_784_GPU(self):
+    if not context.num_gpus():
+      return
+    with context.device(GPU):
+      m = self._m_100_by_784.gpu()
+      self._benchmark_tfe_py_execute_matmul(
+          m, transpose_b=True, num_iters=self._num_iters_100_by_784)
+
+  def benchmark_defun_matmul_100_by_784_GPU(self):
+    if not context.num_gpus():
+      return
+    with context.device(GPU):
+      m = self._m_100_by_784.gpu()
+      self._benchmark_defun_matmul(
+          m, transpose_b=True, num_iters=self._num_iters_100_by_784)
 
 
 if __name__ == "__main__":
-  parser = argparse.ArgumentParser()
-  # Default iterations to 1 to keep continuos integration test times low.
-  parser.add_argument(
-      "--iters",
-      type=int,
-      default=1,
-      help="Number of iterators for each test. None or 0 for auto-selection")
-  FLAGS, unparsed = parser.parse_known_args()
-  sys.argv = [sys.argv[0]] + unparsed
   test.main()
diff --git a/tensorflow/python/eager/pywrap_tensor.cc b/tensorflow/python/eager/pywrap_tensor.cc
index 4cc8f91dbccc225272c4853e2312ea3c58e977c2..ca283862f93c5976ea188cfd6fd90ca1ae97437d 100644
--- a/tensorflow/python/eager/pywrap_tensor.cc
+++ b/tensorflow/python/eager/pywrap_tensor.cc
@@ -720,8 +720,6 @@ PyObject* TFE_Py_TensorShapeSlice(PyObject* tensor_list, int slice_dim) {
             .c_str());
     return nullptr;
   }
-  // handle now owns the tensor. Release it from the smart pointer.
-  tensor.release();
 
   return EagerTensorFromHandle(handle);
 }
diff --git a/tensorflow/python/eager/tensor_test.py b/tensorflow/python/eager/tensor_test.py
index 3e29b69709083b9d2a755ae410299ab0087bddde..7a4593ec464ab1834a555a131b8b717f5010de62 100644
--- a/tensorflow/python/eager/tensor_test.py
+++ b/tensorflow/python/eager/tensor_test.py
@@ -275,6 +275,9 @@ class TFETensorUtilTest(test_util.TensorFlowTestCase):
         r"Slice dimension must be non-negative. Got -2"):
       pywrap_tensorflow.TFE_Py_TensorShapeSlice([t1], -2)
 
+  def testUnicode(self):
+    self.assertEqual(constant_op.constant(u"asdf").numpy(), b"asdf")
+
   def testSliceDimOutOfRange(self):
     t1 = _create_tensor([[1, 2], [3, 4], [5, 6]], dtype=dtypes.int32)
     t2 = _create_tensor([1, 2], dtype=dtypes.int32)
diff --git a/tensorflow/python/estimator/canned/head.py b/tensorflow/python/estimator/canned/head.py
index 88d79de8083d900a483944364ae0c50a81e792e8..01c00621ceb039e039f45452b7fa9385fad2c78f 100644
--- a/tensorflow/python/estimator/canned/head.py
+++ b/tensorflow/python/estimator/canned/head.py
@@ -193,59 +193,6 @@ class _Head(object):
     raise NotImplementedError('Calling an abstract method.')
 
 
-def _maybe_expand_dim(tensor):
-  """Expand the dim of `tensor` with static rank 1."""
-  with ops.name_scope(None, 'maybe_expand_dim', (tensor,)):
-    static_shape = tensor.shape
-    if static_shape is None:
-      return tensor
-
-    return (array_ops.expand_dims(tensor, -1) if static_shape.ndims == 1
-            else tensor)
-
-
-def _check_and_reshape_dense_labels(labels, expected_labels_dimension):
-  """Checks dense labels type and shape and reshapes to 2D Tensor."""
-  if labels is None:
-    raise ValueError(
-        'You must provide a labels Tensor. Given: None. '
-        'Suggested troubleshooting steps: Check that your data contain '
-        'your label feature. Check that your input_fn properly parses and '
-        'returns labels.')
-  with ops.name_scope(None, 'labels', (labels,)) as scope:
-    labels = sparse_tensor.convert_to_tensor_or_sparse_tensor(labels)
-    if isinstance(labels, sparse_tensor.SparseTensor):
-      raise ValueError(
-          'SparseTensor labels are not supported. '
-          'labels must be a Tensor of shape [batch_size, %s]. '
-          'Suggested Fix (1): Check the label feature in your data. '
-          'Each example must contain %s value(s). If not, your choice of label '
-          'was probably incorrect. '
-          'Suggested Fix (2): In your input_fn, use '
-          'tf.sparse_tensor_to_dense() to turn labels into a Tensor.'
-          '' % (expected_labels_dimension, expected_labels_dimension))
-    labels = _maybe_expand_dim(labels)
-    labels_shape = array_ops.shape(labels)
-    err_msg = 'labels shape must be [batch_size, {}]'.format(
-        expected_labels_dimension)
-    assert_rank = check_ops.assert_rank(labels, 2, message=err_msg)
-    with ops.control_dependencies([assert_rank]):
-      static_shape = labels.shape
-      if static_shape is not None:
-        dim1 = static_shape[1]
-        if (dim1 is not None) and (dim1 != expected_labels_dimension):
-          raise ValueError(
-              'Mismatched label shape. '
-              'Classifier configured with n_classes=%s.  Received %s. '
-              'Suggested Fix: check your n_classes argument to the estimator '
-              'and/or the shape of your label.' %
-              (expected_labels_dimension, dim1))
-      assert_dimension = check_ops.assert_equal(
-          expected_labels_dimension, labels_shape[1], message=err_msg)
-      with ops.control_dependencies([assert_dimension]):
-        return array_ops.identity(labels, name=scope)
-
-
 def _check_dense_labels_match_logits_and_reshape(
     labels, logits, expected_labels_dimension):
   """Checks that labels shape matches logits and reshapes if needed.
@@ -323,6 +270,7 @@ def _check_weights_match_logits_and_reshape(weights, logits):
   Consider logits of shape [D0, D1, ... DN, logits_dimension]. Weights shape
   can be either:
   * [D0, D1, ... DN, logits_dimension]
+  * [D0, D1, ... DN, 1]
   * [D0, D1, ... DN]: In this case, weights is reshaped into
     [D0, D1, ... DN, 1] to work with weight broadcasting rules.
 
@@ -359,6 +307,7 @@ def _check_weights_match_logits_and_reshape(weights, logits):
       return array_ops.identity(weights, name=scope)
 
 
+# TODO(roumposg): Delete once all heads support multi-dim input.
 def _check_logits(logits, expected_logits_dimension):
   """Check logits type and shape."""
   with ops.name_scope(None, 'logits', (logits,)) as scope:
@@ -502,7 +451,20 @@ def _multi_class_head_with_softmax_cross_entropy_loss(n_classes,
                                                       name=None):
   """Creates a '_Head' for multi class classification.
 
-  This head expects to be fed integer labels specifying the class index.
+  The head expects `logits` with shape `[D0, D1, ... DN, n_classes]`.
+  In many applications, the shape is `[batch_size, n_classes]`.
+
+  `labels` must be a dense `Tensor` with shape matching `logits`, namely
+  `[D0, D1, ... DN, 1]`. If `label_vocabulary` given, `labels` must be a string
+  `Tensor` with values from the vocabulary. If `label_vocabulary` is not given,
+  `labels` must be an integer `Tensor` with values specifying the class index.
+
+  If `weight_column` is specified, weights must be of shape
+  `[D0, D1, ... DN]`, or `[D0, D1, ... DN, 1]`.
+
+  The loss is the weighted sum over the input dimensions. Namely, if the input
+  labels have shape `[batch_size, 1]`, the loss is the weighted sum over
+  `batch_size`.
 
   Args:
     n_classes: Number of classes, must be greater than 2 (for 2 classes, use
@@ -605,12 +567,18 @@ class _MultiClassHeadWithSoftmaxCrossEntropyLoss(_Head):
   def create_loss(self, features, mode, logits, labels):
     """See `Head`."""
     del mode  # Unused for this head.
-    label_ids = self._label_ids(_check_and_reshape_dense_labels(labels, 1))
+    logits = ops.convert_to_tensor(logits)
+    labels = _check_dense_labels_match_logits_and_reshape(
+        labels=labels, logits=logits, expected_labels_dimension=1)
+    label_ids = self._label_ids(labels)
     unweighted_loss = losses.sparse_softmax_cross_entropy(
         labels=label_ids, logits=logits, reduction=losses.Reduction.NONE)
     # Restore the squeezed dim, so unweighted_loss matches the weights shape.
-    unweighted_loss = array_ops.expand_dims(unweighted_loss, axis=(1,))
+    unweighted_loss = array_ops.expand_dims(unweighted_loss, axis=-1)
     weights = _weights(features, self._weight_column)
+    if self._weight_column is not None:
+      weights = _check_weights_match_logits_and_reshape(
+          weights=weights, logits=logits)
     weighted_sum_loss = losses.compute_weighted_loss(
         unweighted_loss, weights=weights, reduction=losses.Reduction.SUM)
     # _weights() can return 1.
@@ -623,16 +591,32 @@ class _MultiClassHeadWithSoftmaxCrossEntropyLoss(_Head):
 
   def create_estimator_spec(
       self, features, mode, logits, labels=None, train_op_fn=None):
-    """See `Head`."""
+    """Returns an `EstimatorSpec`.
+
+    Args:
+      features: Input `dict` of `Tensor` or `SparseTensor` objects.
+      mode: Estimator's `ModeKeys`.
+      logits: logits `Tensor` with shape `[D0, D1, ... DN, logits_dimension]`.
+        For many applications, the shape is `[batch_size, logits_dimension]`.
+      labels: Labels integer or string `Tensor` with shape matching `logits`,
+        namely `[D0, D1, ... DN, 1]`. `labels` is required argument when `mode`
+        equals `TRAIN` or `EVAL`.
+      train_op_fn: Function that takes a scalar loss `Tensor` and returns
+        `train_op`. Required in TRAIN mode.
+    Returns:
+      `EstimatorSpec`.
+    Raises:
+      ValueError: If `train_op_fn` is `None` in TRAIN mode.
+    """
     with ops.name_scope(self._name, 'head'):
-      logits = _check_logits(logits, self.logits_dimension)
+      logits = _check_logits_final_dim(logits, self.logits_dimension)
 
       # Predict.
       pred_keys = prediction_keys.PredictionKeys
       with ops.name_scope(None, 'predictions', (logits,)):
-        # class_ids's shape is [batch_size]
-        class_ids = math_ops.argmax(logits, 1, name=pred_keys.CLASS_IDS)
-        class_ids = array_ops.expand_dims(class_ids, axis=(1,))
+        # class_ids's shape is [D0, D1, ... DN].
+        class_ids = math_ops.argmax(logits, axis=-1, name=pred_keys.CLASS_IDS)
+        class_ids = array_ops.expand_dims(class_ids, axis=-1)
         if self._label_vocabulary:
           table = lookup_ops.index_to_string_table_from_tensor(
               vocabulary_list=self._label_vocabulary,
@@ -700,7 +684,20 @@ def _binary_logistic_head_with_sigmoid_cross_entropy_loss(
 
   This head uses `sigmoid_cross_entropy_with_logits` loss.
 
-  This head expects to be fed float labels of shape `(batch_size, 1)`.
+  The head expects `logits` with shape `[D0, D1, ... DN, 1]`.
+  In many applications, the shape is `[batch_size, 1]`.
+
+  `labels` must be a dense `Tensor` with shape matching `logits`, namely
+  `[D0, D1, ... DN, 1]`. If `label_vocabulary` given, `labels` must be a string
+  `Tensor` with values from the vocabulary. If `label_vocabulary` is not given,
+  `labels` must be float `Tensor` with values in the interval `[0, 1]`.
+
+  If `weight_column` is specified, weights must be of shape
+  `[D0, D1, ... DN]`, or `[D0, D1, ... DN, 1]`.
+
+  The loss is the weighted sum over the input dimensions. Namely, if the input
+  labels have shape `[batch_size, 1]`, the loss is the weighted sum over
+  `batch_size`.
 
   Args:
     weight_column: A string or a `_NumericColumn` created by
@@ -844,7 +841,9 @@ class _BinaryLogisticHeadWithSigmoidCrossEntropyLoss(_Head):
   def create_loss(self, features, mode, logits, labels):
     """See `Head`."""
     del mode  # Unused for this head.
-    labels = _check_and_reshape_dense_labels(labels, self.logits_dimension)
+    logits = ops.convert_to_tensor(logits)
+    labels = _check_dense_labels_match_logits_and_reshape(
+        labels=labels, logits=logits, expected_labels_dimension=1)
     if self._label_vocabulary is not None:
       labels = lookup_ops.index_table_from_tensor(
           vocabulary_list=tuple(self._label_vocabulary),
@@ -854,6 +853,9 @@ class _BinaryLogisticHeadWithSigmoidCrossEntropyLoss(_Head):
     unweighted_loss = nn.sigmoid_cross_entropy_with_logits(
         labels=labels, logits=logits)
     weights = _weights(features, self._weight_column)
+    if self._weight_column is not None:
+      weights = _check_weights_match_logits_and_reshape(
+          weights=weights, logits=logits)
     weighted_sum_loss = losses.compute_weighted_loss(
         unweighted_loss, weights=weights, reduction=losses.Reduction.SUM)
     # _weights() can return 1.
@@ -871,14 +873,16 @@ class _BinaryLogisticHeadWithSigmoidCrossEntropyLoss(_Head):
     with ops.name_scope(self._name, 'head'):
       with ops.name_scope(None, 'predictions', (logits,)):
         pred_keys = prediction_keys.PredictionKeys
-        logits = _check_logits(logits, self.logits_dimension)
+        logits = _check_logits_final_dim(logits, self.logits_dimension)
         logistic = math_ops.sigmoid(logits, name=pred_keys.LOGISTIC)
         two_class_logits = array_ops.concat(
-            (array_ops.zeros_like(logits), logits), 1, name='two_class_logits')
+            (array_ops.zeros_like(logits), logits),
+            axis=-1, name='two_class_logits')
         probabilities = nn.softmax(
             two_class_logits, name=pred_keys.PROBABILITIES)
-        class_ids = array_ops.reshape(
-            math_ops.argmax(two_class_logits, axis=1), (-1, 1), name='classes')
+        class_ids = math_ops.argmax(
+            two_class_logits, axis=-1, name=pred_keys.CLASS_IDS)
+        class_ids = array_ops.expand_dims(class_ids, axis=-1)
         if self._label_vocabulary:
           table = lookup_ops.index_to_string_table_from_tensor(
               vocabulary_list=self._label_vocabulary,
@@ -914,6 +918,12 @@ class _BinaryLogisticHeadWithSigmoidCrossEntropyLoss(_Head):
 
       # Eval.
       if mode == model_fn.ModeKeys.EVAL:
+        weights = _weights(features, self._weight_column)
+        # TODO(roumposg): Merge this logic inside _weights once all heads
+        # support multi-dimensional inputs.
+        if self._weight_column is not None:
+          weights = _check_weights_match_logits_and_reshape(
+              weights=weights, logits=logits)
         return model_fn.EstimatorSpec(
             mode=model_fn.ModeKeys.EVAL,
             predictions=predictions,
@@ -923,7 +933,7 @@ class _BinaryLogisticHeadWithSigmoidCrossEntropyLoss(_Head):
                 logits=logits,
                 logistic=logistic,
                 class_ids=class_ids,
-                weights=_weights(features, self._weight_column),
+                weights=weights,
                 weighted_sum_loss=weighted_sum_loss,
                 example_weight_sum=example_weight_sum))
 
@@ -1031,9 +1041,6 @@ class _RegressionHeadWithMeanSquaredErrorLoss(_Head):
       self, features, mode, logits, labels=None, train_op_fn=None):
     """Returns an `EstimatorSpec`.
 
-    Please note that,
-    + All args must be passed via name.
-
     Args:
       features: Input `dict` of `Tensor` or `SparseTensor` objects.
       mode: Estimator's `ModeKeys`.
diff --git a/tensorflow/python/estimator/canned/head_test.py b/tensorflow/python/estimator/canned/head_test.py
index 9f95618513785e258ef02ba9e34242c8ee2484d3..0a4ea7d81c9bb5da5dcb21b7aead177ccff13dbc 100644
--- a/tensorflow/python/estimator/canned/head_test.py
+++ b/tensorflow/python/estimator/canned/head_test.py
@@ -155,7 +155,9 @@ class MultiClassHeadWithSoftmaxCrossEntropyLoss(test.TestCase):
         logits=logits_placeholder,
         labels=labels_placeholder)[0]
     with self.test_session():
-      with self.assertRaisesRegexp(errors.OpError, 'labels shape'):
+      with self.assertRaisesRegexp(
+          errors.InvalidArgumentError,
+          r'\[expected_labels_shape: \] \[2 1\] \[labels_shape: \] \[2 2\]'):
         weighted_sum_loss.eval({
             logits_placeholder: logits_2x3,
             labels_placeholder: labels_2x2
@@ -269,8 +271,8 @@ class MultiClassHeadWithSoftmaxCrossEntropyLoss(test.TestCase):
         labels=labels_placeholder)[0]
     with self.test_session():
       with self.assertRaisesRegexp(
-          errors.OpError,
-          'logits and labels must have the same first dimension'):
+          errors.InvalidArgumentError,
+          r'\[expected_labels_shape: \] \[2 1\] \[labels_shape: \] \[3 1\]'):
         weighted_sum_loss.eval({
             labels_placeholder: values_3x1,
             logits_placeholder: values_2x3
@@ -897,6 +899,158 @@ class MultiClassHeadWithSoftmaxCrossEntropyLoss(test.TestCase):
               expected_loss / np.sum(weights_3x1),
       }, summary_str, tol)
 
+  def test_multi_dim_weighted_train_create_loss(self):
+    """Logits of shape [2, 2, 2], labels [2, 2, 1], weights [2, 2]."""
+    head = head_lib._multi_class_head_with_softmax_cross_entropy_loss(
+        n_classes=3, weight_column='weights')
+
+    logits = np.array([[[10, 0, 0], [12, 0, 0]],
+                       [[0, 10, 0], [0, 15, 0]]], dtype=np.float32)
+    labels = np.array([[[0], [1]], [[1], [2]]], dtype=np.int64)
+    weights = np.array([[1., 1.5], [2., 2.5]], dtype=np.float32)
+
+    # loss = cross_entropy(labels, logits) = [[0, 12], [0, 15]].
+    # weighted_sum_loss = 1*0 + 1.5*12 + 2*0 + 2.5*15 = 55.5
+    expected_weighted_sum_loss = 55.5
+    expected_example_weight_sum = np.sum(weights)
+    weighted_sum_loss, example_weight_sum, _ = head.create_loss(
+        features={'weights': weights},
+        mode=model_fn.ModeKeys.TRAIN,
+        logits=logits,
+        labels=labels)
+    with self.test_session():
+      _initialize_variables(self, monitored_session.Scaffold())
+      self.assertAllClose(
+          expected_weighted_sum_loss, weighted_sum_loss.eval(),
+          rtol=1e-2, atol=1e-2)
+      self.assertAllClose(
+          expected_example_weight_sum, example_weight_sum.eval())
+
+  def test_multi_dim_weighted_train(self):
+    """Logits of shape [2, 2, 2], labels [2, 2, 1], weights [2, 2]."""
+    head = head_lib._multi_class_head_with_softmax_cross_entropy_loss(
+        n_classes=3, weight_column='weights')
+
+    logits = np.array([[[10, 0, 0], [12, 0, 0]],
+                       [[0, 10, 0], [0, 15, 0]]], dtype=np.float32)
+    labels = np.array([[[0], [1]], [[1], [2]]], dtype=np.int64)
+    weights = np.array([[1., 1.5], [2., 2.5]], dtype=np.float32)
+    expected_train_result = 'my_train_op'
+    def _train_op_fn(loss):
+      return string_ops.string_join(
+          [constant_op.constant(expected_train_result),
+           string_ops.as_string(loss, precision=2)])
+
+    # loss = cross_entropy(labels, logits) = [[0, 12], [0, 15]].
+    # weighted_sum_loss = 1*0 + 1.5*12 + 2*0 + 2.5*15 = 55.5
+    expected_loss = 55.5
+    spec = head.create_estimator_spec(
+        features={'weights': weights},
+        mode=model_fn.ModeKeys.TRAIN,
+        logits=logits,
+        labels=labels,
+        train_op_fn=_train_op_fn)
+
+    # Assert predictions, loss, train_op, and summaries.
+    tol = 1e-2
+    with self.test_session() as sess:
+      _initialize_variables(self, spec.scaffold)
+      loss, train_result = sess.run((spec.loss, spec.train_op))
+      self.assertAllClose(expected_loss, loss, rtol=tol, atol=tol)
+      self.assertEqual(
+          six.b('{0:s}{1:.2f}'.format(expected_train_result, expected_loss)),
+          train_result)
+
+  def test_multi_dim_train_weights_wrong_inner_dim(self):
+    """Logits of shape [2, 2, 2], labels [2, 2, 1], weights [2, 1]."""
+    head = head_lib._multi_class_head_with_softmax_cross_entropy_loss(
+        n_classes=3, weight_column='weights')
+    logits = np.array([[[10, 0, 0], [12, 0, 0]],
+                       [[0, 10, 0], [0, 15, 0]]], dtype=np.float32)
+    labels = np.array([[[0], [1]], [[1], [2]]], dtype=np.int64)
+    weights = np.array([[1.], [2.]], dtype=np.float32)
+    def _no_op_train_fn(loss):
+      del loss
+      return control_flow_ops.no_op()
+
+    spec = head.create_estimator_spec(
+        features={'weights': weights},
+        mode=model_fn.ModeKeys.TRAIN,
+        logits=logits,
+        labels=labels,
+        train_op_fn=_no_op_train_fn)
+    with self.test_session():
+      _initialize_variables(self, monitored_session.Scaffold())
+      with self.assertRaisesRegexp(
+          errors.InvalidArgumentError,
+          r'\[logits_shape: \] \[2 2 3\] \[weights_shape: \] \[2 1\]'):
+        spec.loss.eval()
+
+  def test_multi_dim_train_weights_wrong_outer_dim(self):
+    """Logits of shape [2, 2, 2], labels [2, 2, 1], weights [2, 2, 2]."""
+    head = head_lib._multi_class_head_with_softmax_cross_entropy_loss(
+        n_classes=3, weight_column='weights')
+    logits = np.array([[[10, 0, 0], [12, 0, 0]],
+                       [[0, 10, 0], [0, 15, 0]]], dtype=np.float32)
+    labels = np.array([[[0], [1]], [[1], [2]]], dtype=np.int64)
+    weights_placeholder = array_ops.placeholder(dtype=dtypes.float32)
+    def _no_op_train_fn(loss):
+      del loss
+      return control_flow_ops.no_op()
+
+    spec = head.create_estimator_spec(
+        features={'weights': weights_placeholder},
+        mode=model_fn.ModeKeys.TRAIN,
+        logits=logits,
+        labels=labels,
+        train_op_fn=_no_op_train_fn)
+    with self.test_session():
+      _initialize_variables(self, monitored_session.Scaffold())
+      with self.assertRaisesRegexp(
+          errors.InvalidArgumentError,
+          r'\[logits_shape: \]\s\[2 2 3\]\s\[weights_shape: \]\s\[2 2 2\]'):
+        spec.loss.eval({
+            weights_placeholder: np.array([[[1., 1.1], [1.5, 1.6]],
+                                           [[2., 2.1], [2.5, 2.6]]])})
+
+  def test_multi_dim_weighted_eval(self):
+    """Logits of shape [2, 2, 2], labels [2, 2, 1], weights [2, 2]."""
+    head = head_lib._multi_class_head_with_softmax_cross_entropy_loss(
+        n_classes=3, weight_column='weights')
+    logits = np.array([[[10, 0, 0], [12, 0, 0]],
+                       [[0, 10, 0], [0, 15, 0]]], dtype=np.float32)
+    labels = np.array([[[0], [1]], [[1], [2]]], dtype=np.int64)
+    weights = np.array([[1., 1.5], [2., 2.5]], dtype=np.float32)
+    # loss = cross_entropy(labels, logits) = [[0, 12], [0, 15]].
+    # weighted_sum_loss = 1*0 + 1.5*12 + 2*0 + 2.5*15 = 55.5
+    expected_loss = 55.5
+    # Create estimator spec.
+    spec = head.create_estimator_spec(
+        features={'weights': weights},
+        mode=model_fn.ModeKeys.EVAL,
+        logits=logits,
+        labels=labels)
+
+    keys = metric_keys.MetricKeys
+    expected_metrics = {
+        keys.LOSS_MEAN: expected_loss / np.sum(weights),
+        keys.ACCURACY: (1.*1. + 1.5*0. + 2.*1. + 2.5*0.) / np.sum(weights),
+    }
+
+    # Assert predictions, loss, and metrics.
+    tol = 1e-2
+    with self.test_session() as sess:
+      _initialize_variables(self, spec.scaffold)
+      value_ops = {k: spec.eval_metric_ops[k][0] for k in spec.eval_metric_ops}
+      update_ops = {k: spec.eval_metric_ops[k][1] for k in spec.eval_metric_ops}
+      loss, metrics = sess.run((spec.loss, update_ops))
+      self.assertAllClose(expected_loss, loss, rtol=tol, atol=tol)
+      # Check results of both update (in `metrics`) and value ops.
+      self.assertAllClose(expected_metrics, metrics, rtol=tol, atol=tol)
+      self.assertAllClose(
+          expected_metrics, {k: value_ops[k].eval() for k in value_ops},
+          rtol=tol, atol=tol)
+
 
 class BinaryLogisticHeadWithSigmoidCrossEntropyLossTest(test.TestCase):
 
@@ -964,7 +1118,9 @@ class BinaryLogisticHeadWithSigmoidCrossEntropyLossTest(test.TestCase):
         logits=logits_placeholder,
         labels=labels_placeholder)[0]
     with self.test_session():
-      with self.assertRaisesRegexp(errors.OpError, 'labels shape'):
+      with self.assertRaisesRegexp(
+          errors.InvalidArgumentError,
+          r'\[expected_labels_shape: \] \[2 1\] \[labels_shape: \] \[2 2\]'):
         weighted_sum_loss.eval({
             logits_placeholder: logits_2x1,
             labels_placeholder: labels_2x2
@@ -1003,13 +1159,17 @@ class BinaryLogisticHeadWithSigmoidCrossEntropyLossTest(test.TestCase):
         logits=logits_placeholder,
         labels=labels_placeholder)[0]
     with self.test_session():
-      with self.assertRaisesRegexp(errors.OpError, 'Incompatible shapes'):
+      with self.assertRaisesRegexp(
+          errors.InvalidArgumentError,
+          r'\[expected_labels_shape: \] \[3 1\] \[labels_shape: \] \[2 1\]'):
         weighted_sum_loss.eval({
             labels_placeholder: values_2x1,
             logits_placeholder: values_3x1
         })
     with self.test_session():
-      with self.assertRaisesRegexp(errors.OpError, 'Incompatible shapes'):
+      with self.assertRaisesRegexp(
+          errors.InvalidArgumentError,
+          r'\[expected_labels_shape: \] \[2 1\] \[labels_shape: \] \[3 1\]'):
         weighted_sum_loss.eval({
             labels_placeholder: values_3x1,
             logits_placeholder: values_2x1
@@ -1765,6 +1925,165 @@ class BinaryLogisticHeadWithSigmoidCrossEntropyLossTest(test.TestCase):
           metric_keys.MetricKeys.LOSS_MEAN: 26.9615384615,
       }, summary_str)
 
+  def test_multi_dim_weighted_train_create_loss(self):
+    """Logits and labels of shape [2, 2, 1], weights [2, 2]."""
+    head = head_lib._binary_logistic_head_with_sigmoid_cross_entropy_loss(
+        weight_column='weights')
+
+    logits = np.array([[[10], [-10]], [[12], [-12]]], dtype=np.float32)
+    labels = np.array([[[0], [0]], [[1], [1]]], dtype=np.float64)
+    weights = np.array([[1., 1.5], [2., 2.5]], dtype=np.float32)
+    # loss = cross_entropy(labels, logits) = [[10, 0], [0, 12]].
+    # weighted_sum_loss = 1*10 + 1.5*0 + 2*0 + 2.5*12 = 40
+    expected_weighted_sum_loss = 40.
+    expected_example_weight_sum = np.sum(weights)
+    # Create loss.
+    weighted_sum_loss, example_weight_sum, _ = head.create_loss(
+        features={'weights': weights},
+        mode=model_fn.ModeKeys.TRAIN,
+        logits=logits,
+        labels=labels)
+    tol = 1e-2
+    with self.test_session():
+      _initialize_variables(self, monitored_session.Scaffold())
+      self.assertAllClose(
+          expected_weighted_sum_loss, weighted_sum_loss.eval(),
+          rtol=tol, atol=tol)
+      self.assertAllClose(
+          expected_example_weight_sum, example_weight_sum.eval())
+
+  def test_multi_dim_weighted_train(self):
+    """Logits and labels of shape [2, 2, 1], weights [2, 2]."""
+    head = head_lib._binary_logistic_head_with_sigmoid_cross_entropy_loss(
+        weight_column='weights')
+
+    logits = np.array([[[10], [-10]], [[12], [-12]]], dtype=np.float32)
+    labels = np.array([[[0], [0]], [[1], [1]]], dtype=np.float64)
+    weights = np.array([[1., 1.5], [2., 2.5]], dtype=np.float32)
+    # loss = cross_entropy(labels, logits) = [[10, 0], [0, 12]].
+    # weighted_sum_loss = 1*10 + 1.5*0 + 2*0 + 2.5*12 = 40
+    expected_loss = 40.
+    expected_train_result = 'my_train_op'
+    def _train_op_fn(loss):
+      return string_ops.string_join(
+          [constant_op.constant(expected_train_result),
+           string_ops.as_string(loss, precision=2)])
+
+    # Create estimator spec.
+    spec = head.create_estimator_spec(
+        features={'weights': weights},
+        mode=model_fn.ModeKeys.TRAIN,
+        logits=logits,
+        labels=labels,
+        train_op_fn=_train_op_fn)
+
+    # Assert predictions, loss, train_op, and summaries.
+    tol = 1e-2
+    with self.test_session() as sess:
+      _initialize_variables(self, spec.scaffold)
+      loss, train_result = sess.run((spec.loss, spec.train_op))
+      self.assertAllClose(expected_loss, loss, rtol=tol, atol=tol)
+      self.assertEqual(
+          six.b('{0:s}{1:.2f}'.format(expected_train_result, expected_loss)),
+          train_result)
+
+  def test_multi_dim_train_weights_wrong_inner_dim(self):
+    """Logits and labels of shape [2, 2, 1], weights [2, 1]."""
+    head = head_lib._binary_logistic_head_with_sigmoid_cross_entropy_loss(
+        weight_column='weights')
+
+    logits = np.array([[[10], [-10]], [[12], [-12]]], dtype=np.float32)
+    labels = np.array([[[0], [0]], [[1], [1]]], dtype=np.float64)
+    weights = np.array([[1.], [2.]], dtype=np.float32)
+    def _no_op_train_fn(loss):
+      del loss
+      return control_flow_ops.no_op()
+
+    spec = head.create_estimator_spec(
+        features={'weights': weights},
+        mode=model_fn.ModeKeys.TRAIN,
+        logits=logits,
+        labels=labels,
+        train_op_fn=_no_op_train_fn)
+    with self.test_session():
+      _initialize_variables(self, monitored_session.Scaffold())
+      with self.assertRaisesRegexp(
+          errors.InvalidArgumentError,
+          r'\[logits_shape: \] \[2 2 1\] \[weights_shape: \] \[2 1\]'):
+        spec.loss.eval()
+
+  def test_multi_dim_train_weights_wrong_outer_dim(self):
+    """Logits and labels of shape [2, 2, 1], weights [2, 2, 2]."""
+    head = head_lib._binary_logistic_head_with_sigmoid_cross_entropy_loss(
+        weight_column='weights')
+
+    logits = np.array([[[10], [-10]], [[12], [-12]]], dtype=np.float32)
+    labels = np.array([[[0], [0]], [[1], [1]]], dtype=np.float64)
+    weights_placeholder = array_ops.placeholder(dtype=dtypes.float32)
+    def _no_op_train_fn(loss):
+      del loss
+      return control_flow_ops.no_op()
+
+    spec = head.create_estimator_spec(
+        features={'weights': weights_placeholder},
+        mode=model_fn.ModeKeys.TRAIN,
+        logits=logits,
+        labels=labels,
+        train_op_fn=_no_op_train_fn)
+    with self.test_session():
+      _initialize_variables(self, monitored_session.Scaffold())
+      with self.assertRaisesRegexp(
+          errors.InvalidArgumentError,
+          r'\[logits_shape: \]\s\[2 2 1\]\s\[weights_shape: \]\s\[2 2 2\]'):
+        spec.loss.eval({
+            weights_placeholder: np.array([[[1., 1.1], [1.5, 1.6]],
+                                           [[2., 2.1], [2.5, 2.6]]])})
+
+  def test_multi_dim_weighted_eval(self):
+    """Logits and labels of shape [2, 2, 1], weights [2, 2]."""
+    head = head_lib._binary_logistic_head_with_sigmoid_cross_entropy_loss(
+        weight_column='weights')
+
+    logits = np.array([[[10], [-10]], [[12], [-12]]], dtype=np.float32)
+    labels = np.array([[[0], [0]], [[1], [1]]], dtype=np.float64)
+    weights = np.array([[1., 1.5], [2., 2.5]], dtype=np.float32)
+    # loss = cross_entropy(labels, logits) = [[10, 0], [0, 12]].
+    # weighted_sum_loss = 1*10 + 1.5*0 + 2*0 + 2.5*12 = 40
+    expected_loss = 40.
+
+    # Create estimator spec.
+    spec = head.create_estimator_spec(
+        features={'weights': weights},
+        mode=model_fn.ModeKeys.EVAL,
+        logits=logits,
+        labels=labels)
+
+    keys = metric_keys.MetricKeys
+    expected_metrics = {
+        keys.LOSS_MEAN: expected_loss / np.sum(weights),
+        keys.ACCURACY: (1.*0. + 1.5*1. + 2.*1. + 2.5*0.) / np.sum(weights),
+        keys.PREDICTION_MEAN: (1.*1 + 1.5*0 + 2.*1 + 2.5*0) / np.sum(weights),
+        keys.LABEL_MEAN: (1.*0 + 1.5*0 + 2.*1 + 2.5*1) / np.sum(weights),
+        keys.ACCURACY_BASELINE: (1.*0 + 1.5*0 + 2.*1 + 2.5*1) / np.sum(weights),
+        # We cannot reliably calculate AUC with only 4 data points, but the
+        # values should not change because of backwards-compatibility.
+        keys.AUC: 0.5222,
+        keys.AUC_PR: 0.7341,
+    }
+
+    tol = 1e-2
+    with self.test_session() as sess:
+      _initialize_variables(self, spec.scaffold)
+      value_ops = {k: spec.eval_metric_ops[k][0] for k in spec.eval_metric_ops}
+      update_ops = {k: spec.eval_metric_ops[k][1] for k in spec.eval_metric_ops}
+      loss, metrics = sess.run((spec.loss, update_ops))
+      self.assertAllClose(expected_loss, loss, rtol=tol, atol=tol)
+      # Check results of both update (in `metrics`) and value ops.
+      self.assertAllClose(expected_metrics, metrics, rtol=tol, atol=tol)
+      self.assertAllClose(
+          expected_metrics, {k: value_ops[k].eval() for k in value_ops},
+          rtol=tol, atol=tol)
+
 
 class RegressionHeadWithMeanSquaredErrorLossTest(test.TestCase):
 
diff --git a/tensorflow/python/estimator/estimator.py b/tensorflow/python/estimator/estimator.py
index 6243cfc118b6cc16cb6d6bfeb9ad5aab72a6d702..a730e107baeef3d091051e11b4c9e5db190f81a9 100644
--- a/tensorflow/python/estimator/estimator.py
+++ b/tensorflow/python/estimator/estimator.py
@@ -26,6 +26,7 @@ import tempfile
 import numpy as np
 import six
 
+from google.protobuf import message
 from tensorflow.core.framework import summary_pb2
 from tensorflow.core.protobuf import config_pb2
 from tensorflow.python.client import session as tf_session
@@ -998,20 +999,27 @@ def _write_dict_to_summary(output_dir,
       continue
     if key == 'global_step':
       continue
-    value = summary_proto.value.add()
-    value.tag = key
     if (isinstance(dictionary[key], np.float32) or
         isinstance(dictionary[key], float)):
-      value.simple_value = float(dictionary[key])
+      summary_proto.value.add(tag=key, simple_value=float(dictionary[key]))
     elif (isinstance(dictionary[key], np.int64) or
           isinstance(dictionary[key], np.int32) or
           isinstance(dictionary[key], int)):
-      value.simple_value = int(dictionary[key])
+      summary_proto.value.add(tag=key, simple_value=int(dictionary[key]))
+    elif isinstance(dictionary[key], six.string_types):
+      try:
+        summ = summary_pb2.Summary.FromString(dictionary[key])
+        for i, _ in enumerate(summ.value):
+          summ.value[i].tag = key
+        summary_proto.value.extend(summ.value)
+      except message.DecodeError:
+        logging.warn('Skipping summary for %s, cannot parse string to Summary.',
+                     key)
+        continue
     else:
       logging.warn(
           'Skipping summary for %s, must be a float, np.float32, np.int64, '
-          'np.int32 or int.',
-          key)
+          'np.int32 or int or a serialized string of Summary.', key)
   summary_writer.add_summary(summary_proto, current_global_step)
   summary_writer.flush()
 
diff --git a/tensorflow/python/estimator/estimator_test.py b/tensorflow/python/estimator/estimator_test.py
index 0040ec3650a073d6d1996491645da7970317ea12..2b9b44523bb919d84f77c7773adf617b796f2702 100644
--- a/tensorflow/python/estimator/estimator_test.py
+++ b/tensorflow/python/estimator/estimator_test.py
@@ -57,6 +57,7 @@ from tensorflow.python.platform import test
 from tensorflow.python.platform import tf_logging as logging
 from tensorflow.python.saved_model import loader
 from tensorflow.python.saved_model import tag_constants
+from tensorflow.python.summary import summary
 from tensorflow.python.summary import summary_iterator
 from tensorflow.python.summary.writer import writer_cache
 from tensorflow.python.training import basic_session_run_hooks
@@ -75,6 +76,23 @@ def dummy_model_fn(features, labels, params):
   _, _, _ = features, labels, params
 
 
+def check_eventfile_for_keyword(keyword, est):
+  """Checks event files for the keyword."""
+
+  writer_cache.FileWriterCache.clear()
+
+  # Get last Event written.
+  event_paths = glob.glob(os.path.join(est.model_dir, 'events*'))
+  last_event = None
+  for last_event in summary_iterator.summary_iterator(event_paths[-1]):
+    if last_event.summary is not None:
+      if last_event.summary.value:
+        if keyword in last_event.summary.value[0].tag:
+          return True
+
+  return False
+
+
 class EstimatorInheritanceConstraintTest(test.TestCase):
   """Tests that sub classes cannot override methods of Estimator."""
 
@@ -584,15 +602,9 @@ class EstimatorTrainTest(test.TestCase):
     # Make sure nothing is stuck in limbo.
     writer_cache.FileWriterCache.clear()
 
-    # Get last Event written.
-    event_paths = glob.glob(os.path.join(est.model_dir, 'events*'))
-    last_event = None
-    for last_event in summary_iterator.summary_iterator(event_paths[-1]):
-      if last_event.summary is not None:
-        if last_event.summary.value:
-          if 'loss' == last_event.summary.value[0].tag:
-            return
-    self.fail('loss should be part of reported summaries.')
+    if check_eventfile_for_keyword('loss', est):
+      return
+    self.fail('{} should be part of reported summaries.'.format('loss'))
 
   def test_latest_checkpoint(self):
     est = estimator.Estimator(model_fn=model_fn_global_step_incrementer)
@@ -1139,6 +1151,39 @@ class EstimatorEvaluateTest(test.TestCase):
     est.evaluate(dummy_input_fn, steps=1)
     self.assertTrue(hook.begin.called)
 
+  def test_summary_writing_with_summary_proto(self):
+
+    def model_fn_global_step_incrementer_image(features, labels, mode):
+      _, _ = features, labels
+      global_step = training.get_global_step()
+
+      image = array_ops.zeros([1, 3, 3, 1])
+      eval_metric_ops = {
+          'image': (summary.image('image', image, max_outputs=1),
+                    constant_op.constant(1))
+      }
+      return model_fn_lib.EstimatorSpec(
+          mode,
+          loss=constant_op.constant(1.),
+          train_op=state_ops.assign_add(global_step, 1),
+          eval_metric_ops=eval_metric_ops)
+
+    est = estimator.Estimator(model_fn=model_fn_global_step_incrementer_image,
+                              config=run_config.RunConfig(save_summary_steps=1))
+    est.train(dummy_input_fn, steps=200)
+    est.evaluate(
+        input_fn=dummy_input_fn,
+        steps=200,
+    )
+
+    # Make sure nothing is stuck in limbo.
+    writer_cache.FileWriterCache.clear()
+
+    # Get last Event written.
+    if check_eventfile_for_keyword('image', est):
+      return
+    self.fail('{} should be part of reported summaries.'.format('image'))
+
 
 class EstimatorPredictTest(test.TestCase):
 
diff --git a/tensorflow/python/estimator/inputs/numpy_io.py b/tensorflow/python/estimator/inputs/numpy_io.py
index c9f37f06e834e0d8be756097130d4cd5136ba9cf..3512f66284f93806f897d65afd765fba54bc2af1 100644
--- a/tensorflow/python/estimator/inputs/numpy_io.py
+++ b/tensorflow/python/estimator/inputs/numpy_io.py
@@ -19,6 +19,7 @@ from __future__ import division
 from __future__ import print_function
 
 import collections
+from six import string_types
 from tensorflow.python.estimator.inputs.queues import feeding_functions
 
 # Key name to pack the target into dict of `features`. See
@@ -51,8 +52,9 @@ def numpy_input_fn(x,
                    num_threads=1):
   """Returns input function that would feed dict of numpy arrays into the model.
 
-  This returns a function outputting `features` and `target` based on the dict
-  of numpy arrays. The dict `features` has the same keys as the `x`.
+  This returns a function outputting `features` and `targets` based on the dict
+  of numpy arrays. The dict `features` has the same keys as the `x`. The dict
+  `targets` has the same keys as the `y` if `y` is a dict.
 
   Example:
 
@@ -69,7 +71,7 @@ def numpy_input_fn(x,
 
   Args:
     x: dict of numpy array object.
-    y: numpy array object. `None` if absent.
+    y: numpy array object or dict of numpy array object. `None` if absent.
     batch_size: Integer, size of batches to return.
     num_epochs: Integer, number of epochs to iterate over data. If `None` will
       run forever.
@@ -81,11 +83,13 @@ def numpy_input_fn(x,
       such as in prediction and evaluation mode, `num_threads` should be 1.
 
   Returns:
-    Function, that has signature of ()->(dict of `features`, `target`)
+    Function, that has signature of ()->(dict of `features`, `targets`)
 
   Raises:
     ValueError: if the shape of `y` mismatches the shape of values in `x` (i.e.,
       values in `x` have same shape).
+    ValueError: if duplicate keys are in both `x` and `y` when `y` is a dict.
+    ValueError: if x or y is an empty dict.
     TypeError: `x` is not a dict or `shuffle` is not bool.
   """
 
@@ -97,43 +101,76 @@ def numpy_input_fn(x,
     """Numpy input function."""
     if not isinstance(x, dict):
       raise TypeError('x must be dict; got {}'.format(type(x).__name__))
+    if not x:
+      raise ValueError('x cannot be empty')
 
     # Make a shadow copy and also ensure the order of iteration is consistent.
-    ordered_dict_x = collections.OrderedDict(
+    ordered_dict_data = collections.OrderedDict(
         sorted(x.items(), key=lambda t: t[0]))
+    # Deep copy keys which is a view in python 3
+    feature_keys = list(ordered_dict_data.keys())
+
+    if y is None:
+      target_keys = None
+    elif isinstance(y, dict):
+      if not y:
+        raise ValueError('y cannot be empty dict, use None instead.')
+
+      ordered_dict_y = collections.OrderedDict(
+        sorted(y.items(), key=lambda t: t[0]))
+      target_keys = list(ordered_dict_y.keys())
+
+      duplicate_keys = set(feature_keys).intersection(set(target_keys))
+      if len(duplicate_keys):
+        raise ValueError('{} duplicate keys are found in both x and y: '
+                         '{}'.format(len(duplicate_keys), duplicate_keys))
+
+      ordered_dict_data.update(ordered_dict_y)
+    else:
+      target_keys = _get_unique_target_key(ordered_dict_data)
+      ordered_dict_data[target_keys] = y
+
+    if len(set(v.shape[0] for v in ordered_dict_data.values())) != 1:
+      shape_dict_of_x = {k: ordered_dict_data[k].shape
+                         for k in feature_keys}
+
+      if target_keys is None:
+        shape_of_y = None
+      elif isinstance(target_keys, string_types):
+        shape_of_y = y.shape
+      else:
+        shape_of_y = {k: ordered_dict_data[k].shape
+                      for k in target_keys}
 
-    unique_target_key = _get_unique_target_key(ordered_dict_x)
-    if y is not None:
-      ordered_dict_x[unique_target_key] = y
-
-    if len(set(v.shape[0] for v in ordered_dict_x.values())) != 1:
-      shape_dict_of_x = {k: ordered_dict_x[k].shape
-                         for k in ordered_dict_x.keys()}
-      shape_of_y = None if y is None else y.shape
       raise ValueError('Length of tensors in x and y is mismatched. All '
                        'elements in x and y must have the same length.\n'
                        'Shapes in x: {}\n'
-                       'Shape for y: {}\n'.format(shape_dict_of_x, shape_of_y))
+                       'Shapes in y: {}\n'.format(shape_dict_of_x, shape_of_y))
 
     queue = feeding_functions._enqueue_data(  # pylint: disable=protected-access
-        ordered_dict_x,
+        ordered_dict_data,
         queue_capacity,
         shuffle=shuffle,
         num_threads=num_threads,
         enqueue_size=batch_size,
         num_epochs=num_epochs)
 
-    features = (queue.dequeue_many(batch_size) if num_epochs is None
+    batch = (queue.dequeue_many(batch_size) if num_epochs is None
                 else queue.dequeue_up_to(batch_size))
 
-    # Remove the first `Tensor` in `features`, which is the row number.
-    if len(features) > 0:
-      features.pop(0)
+    # Remove the first `Tensor` in `batch`, which is the row number.
+    if len(batch) > 0:
+      batch.pop(0)
 
-    features = dict(zip(ordered_dict_x.keys(), features))
-    if y is not None:
-      target = features.pop(unique_target_key)
+    features = dict(zip(feature_keys, batch[:len(feature_keys)]))
+    if target_keys is None:
+      # TODO(martinwicke), return consistent result
+      return features
+    elif isinstance(target_keys, string_types):
+      target = batch[-1]
+      return features, target
+    else:
+      target = dict(zip(target_keys, batch[-len(target_keys):]))
       return features, target
-    return features
 
   return input_fn
diff --git a/tensorflow/python/estimator/inputs/numpy_io_test.py b/tensorflow/python/estimator/inputs/numpy_io_test.py
index 02df22b6323c65243893e1e8b0c5e8c3d74e1a62..65eae7a7dcb1b80d57c7da96f6e26ee4c964ea47 100644
--- a/tensorflow/python/estimator/inputs/numpy_io_test.py
+++ b/tensorflow/python/estimator/inputs/numpy_io_test.py
@@ -239,6 +239,40 @@ class NumpyIoTest(test.TestCase):
             x, y, batch_size=2, shuffle=False, num_epochs=1)
         failing_input_fn()
 
+  def testNumpyInputFnWithXIsEmptyDict(self):
+    x = {}
+    y = np.arange(4)
+    with self.test_session():
+      with self.assertRaisesRegexp(ValueError, 'x cannot be empty'):
+        failing_input_fn = numpy_io.numpy_input_fn(x, y, shuffle=False)
+        failing_input_fn()
+
+  def testNumpyInputFnWithYIsNone(self):
+    a = np.arange(4) * 1.0
+    b = np.arange(32, 36)
+    x = {'a': a, 'b': b}
+    y = None
+
+    with self.test_session() as session:
+      input_fn = numpy_io.numpy_input_fn(
+        x, y, batch_size=2, shuffle=False, num_epochs=1)
+      features_tensor = input_fn()
+
+      coord = coordinator.Coordinator()
+      threads = queue_runner_impl.start_queue_runners(session, coord=coord)
+
+      feature = session.run(features_tensor)
+      self.assertEqual(len(feature), 2)
+      self.assertAllEqual(feature['a'], [0, 1])
+      self.assertAllEqual(feature['b'], [32, 33])
+
+      session.run([features_tensor])
+      with self.assertRaises(errors.OutOfRangeError):
+        session.run([features_tensor])
+
+      coord.request_stop()
+      coord.join(threads)
+
   def testNumpyInputFnWithNonBoolShuffle(self):
     x = np.arange(32, 36)
     y = np.arange(4)
@@ -285,6 +319,59 @@ class NumpyIoTest(test.TestCase):
             num_epochs=1)
         failing_input_fn()
 
+  def testNumpyInputFnWithYAsDict(self):
+    a = np.arange(4) * 1.0
+    b = np.arange(32, 36)
+    x = {'a': a, 'b': b}
+    y = {'y1': np.arange(-32, -28), 'y2': np.arange(32, 28, -1)}
+
+    with self.test_session() as session:
+      input_fn = numpy_io.numpy_input_fn(
+        x, y, batch_size=2, shuffle=False, num_epochs=1)
+      features_tensor, targets_tensor = input_fn()
+
+      coord = coordinator.Coordinator()
+      threads = queue_runner_impl.start_queue_runners(session, coord=coord)
+
+      features, targets = session.run([features_tensor, targets_tensor])
+      self.assertEqual(len(features), 2)
+      self.assertAllEqual(features['a'], [0, 1])
+      self.assertAllEqual(features['b'], [32, 33])
+      self.assertEqual(len(targets), 2)
+      self.assertAllEqual(targets['y1'], [-32, -31])
+      self.assertAllEqual(targets['y2'], [32, 31])
+
+      session.run([features_tensor, targets_tensor])
+      with self.assertRaises(errors.OutOfRangeError):
+        session.run([features_tensor, targets_tensor])
+
+      coord.request_stop()
+      coord.join(threads)
+
+  def testNumpyInputFnWithYIsEmptyDict(self):
+    a = np.arange(4) * 1.0
+    b = np.arange(32, 36)
+    x = {'a': a, 'b': b}
+    y = {}
+    with self.test_session():
+      with self.assertRaisesRegexp(ValueError, 'y cannot be empty'):
+        failing_input_fn = numpy_io.numpy_input_fn(x, y, shuffle=False)
+        failing_input_fn()
+
+  def testNumpyInputFnWithDuplicateKeysInXAndY(self):
+    a = np.arange(4) * 1.0
+    b = np.arange(32, 36)
+    x = {'a': a, 'b': b}
+    y = {'y1': np.arange(-32, -28),
+         'a': a,
+         'y2': np.arange(32, 28, -1),
+         'b': b}
+    with self.test_session():
+      with self.assertRaisesRegexp(
+              ValueError, '2 duplicate keys are found in both x and y'):
+        failing_input_fn = numpy_io.numpy_input_fn(x, y, shuffle=False)
+        failing_input_fn()
+
 
 if __name__ == '__main__':
   test.main()
diff --git a/tensorflow/python/estimator/warm_starting_util.py b/tensorflow/python/estimator/warm_starting_util.py
index 3f0218af83545df4f3a6e8ba709c3aeae8f3bca6..e5655db08201601030c4473e3194e89ef89f5a68 100644
--- a/tensorflow/python/estimator/warm_starting_util.py
+++ b/tensorflow/python/estimator/warm_starting_util.py
@@ -46,10 +46,13 @@ class _WarmStartSettings(
     ckpt_to_initialize_from: [Required] A string specifying the directory with
       checkpoint file(s) or path to checkpoint from which to warm-start the
       model parameters.
-    col_to_prev_vocab: [Optional] Dict of `FeatureColumn` to path of the
-      vocabulary used for the `FeatureColumn` in `ckpt_to_initialize_from`. If
-      not explicitly provided, the vocabularies are assumed to be same between
-      previous and present checkpoints.
+    col_to_prev_vocab: [Optional] Dict of `FeatureColumn` to vocabularies used
+      for the `FeatureColumn` in `ckpt_to_initialize_from`.  Vocabularies can
+      be represented either by a string (path to vocabulary), or tuple of
+      (string, int), representing (path of the vocabulary, vocab_size) if only
+      `vocab_size` entries of the old vocabulary were used in the checkpoint. If
+      the dict is not explicitly provided, the vocabularies are assumed to be
+      same between previous and present checkpoints.
     col_to_prev_tensor: [Optional] Dict of `FeatureColumn` to name of the
       variable (corresponding to the `FeatureColumn`) in
       `ckpt_to_initialize_from`. If not explicitly provided, the name of the
@@ -75,6 +78,13 @@ class _WarmStartSettings(
   ws = _WarmStartSettings(ckpt_to_initialize_from="/tmp",
                           col_to_prev_vocab={sc_vocab_file: "old_vocab.txt"})
 
+  # Warm-start all weights but the parameters corresponding to "sc_vocab_file"
+  # have a different vocab from the one used in current checkpoint, and only
+  # 100 of those entries were used.
+  ws = _WarmStartSettings(ckpt_to_initialize_from="/tmp",
+                          col_to_prev_vocab={sc_vocab_file:
+                                             ("old_vocab.txt", 100)})
+
   # Warm-start all weights but the parameters corresponding to "sc_vocab_file"
   # have a different vocab from the one used in current checkpoint and the
   # parameters corresponding to "sc_vocab_list" have a different name from the
@@ -214,6 +224,7 @@ def _warmstart_var_with_vocab(var,
                               current_vocab_size,
                               prev_ckpt,
                               prev_vocab_path,
+                              previous_vocab_size=-1,
                               current_oov_buckets=0,
                               prev_tensor_name=None,
                               initializer=None):
@@ -239,6 +250,8 @@ def _warmstart_var_with_vocab(var,
       to checkpoint. The given checkpoint must have tensor with name
       `prev_tensor_name` (if not None) or tensor with name same as given `var`.
     prev_vocab_path: Path to the vocab file used for the tensor in `prev_ckpt`.
+    previous_vocab_size: If provided, will constrain previous vocab to the first
+      `previous_vocab_size` entries.  -1 means use the entire previous vocab.
     current_oov_buckets: An `int` specifying the number of out-of-vocabulary
       buckets used for given `var`.
     prev_tensor_name: Name of the tensor to lookup in provided `prev_ckpt`. If
@@ -284,6 +297,7 @@ def _warmstart_var_with_vocab(var,
         old_tensor_name=prev_tensor_name,
         new_row_vocab_size=current_vocab_size,
         new_col_vocab_size=v_shape[1],
+        old_row_vocab_size=previous_vocab_size,
         old_row_vocab_file=prev_vocab_path,
         new_row_vocab_file=current_vocab_path,
         old_col_vocab_file=None,
@@ -373,17 +387,30 @@ def _warmstart_input_layer(cols_to_vars, warmstart_settings):
         vocabulary_file = col.vocabulary_file
         vocabulary_size = col.vocabulary_size
         num_oov_buckets = col.num_oov_buckets
-      prev_vocab_path = warmstart_settings.col_to_prev_vocab.get(
+      prev_vocab = warmstart_settings.col_to_prev_vocab.get(
           col, vocabulary_file)
-      logging.info("Warm-starting column: {}; prev_vocab: {}; prev_tensor: {}".
-                   format(col.name, prev_vocab_path, (
-                       prev_tensor_name or "Unchanged")))
+      if isinstance(prev_vocab, str):
+        prev_vocab_path = prev_vocab
+        previous_vocab_size = -1
+        logging.info(
+            "Warm-starting column: {}; prev_vocab: {}; "
+            "prev_tensor: {}".format(col.name, prev_vocab_path,
+                                     (prev_tensor_name or "Unchanged")))
+      elif isinstance(prev_vocab, tuple):
+        prev_vocab_path = prev_vocab[0]
+        previous_vocab_size = prev_vocab[1]
+        logging.info("Warm-starting column: {}; prev_vocab: {} (first {} "
+                     "entries); prev_tensor: {}".format(
+                         col.name, prev_vocab_path, previous_vocab_size,
+                         (prev_tensor_name or "Unchanged")))
+
       _warmstart_var_with_vocab(
           var,
           current_vocab_path=vocabulary_file,
           current_vocab_size=vocabulary_size,
           prev_ckpt=warmstart_settings.ckpt_to_initialize_from,
           prev_vocab_path=prev_vocab_path,
+          previous_vocab_size=previous_vocab_size,
           current_oov_buckets=num_oov_buckets,
           prev_tensor_name=prev_tensor_name,
           initializer=initializer)
diff --git a/tensorflow/python/estimator/warm_starting_util_test.py b/tensorflow/python/estimator/warm_starting_util_test.py
index f488957fb47c167484e1c1d8409c7278360a624c..a05dbfd7449c9e108649da9ec5a40fe220233953 100644
--- a/tensorflow/python/estimator/warm_starting_util_test.py
+++ b/tensorflow/python/estimator/warm_starting_util_test.py
@@ -318,6 +318,32 @@ class WarmStartingUtilTest(test.TestCase):
         self.assertAllEqual([[2.], [1.5], [1.], [0.5], [0.]],
                             fruit_weights.eval(sess))
 
+  def testWarmStartVarWithVocabConstrainedOldVocabSize(self):
+    prev_vocab_path = self._write_vocab(["apple", "banana", "guava", "orange"],
+                                        "old_vocab")
+    _, _ = self._create_prev_run_var(
+        "fruit_weights", initializer=[[0.5], [1.], [1.5], [2.]])
+
+    # New vocab with elements in reverse order and one new element.
+    new_vocab_path = self._write_vocab(
+        ["orange", "guava", "banana", "apple", "raspberry"], "new_vocab")
+    # New session and new graph.
+    with ops.Graph().as_default() as g:
+      with self.test_session(graph=g) as sess:
+        fruit_weights = variable_scope.get_variable(
+            "fruit_weights", initializer=[[0.], [0.], [0.], [0.], [0.]])
+        ws_util._warmstart_var_with_vocab(
+            fruit_weights,
+            new_vocab_path,
+            5,
+            self.get_temp_dir(),
+            prev_vocab_path,
+            previous_vocab_size=2)
+        sess.run(variables.global_variables_initializer())
+        # Old vocabulary limited to ['apple', 'banana'].
+        self.assertAllEqual([[0.], [0.], [1.], [0.5], [0.]],
+                            fruit_weights.eval(sess))
+
   def testWarmStartVarWithVocabPrevVarPartitioned(self):
     prev_vocab_path = self._write_vocab(["apple", "banana", "guava", "orange"],
                                         "old_vocab")
@@ -507,6 +533,51 @@ class WarmStartingUtilTest(test.TestCase):
         self._assert_cols_to_vars(cols_to_vars, {sc_vocab: [prev_vocab_val]},
                                   sess)
 
+  def testWarmStartInputLayer_SparseColumnVocabularyConstrainedVocabSizes(self):
+    # Create old vocabulary, and use a size smaller than the total number of
+    # entries.
+    old_vocab_path = self._write_vocab(["apple", "guava", "banana"],
+                                       "old_vocab")
+    old_vocab_size = 2  # ['apple', 'guava']
+
+    # Create new vocab for sparse column "sc_vocab".
+    current_vocab_path = self._write_vocab(
+        ["apple", "banana", "guava", "orange"], "current_vocab")
+    # Create feature column.  Only use 2 of the actual entries, resulting in
+    # ['apple', 'banana'] for the new vocabulary.
+    sc_vocab = fc.categorical_column_with_vocabulary_file(
+        "sc_vocab", vocabulary_file=current_vocab_path, vocabulary_size=2)
+
+    # Save checkpoint from which to warm-start.
+    self._create_prev_run_var(
+        "linear_model/sc_vocab/weights", shape=[2, 1], initializer=ones())
+
+    partitioner = lambda shape, dtype: [1] * len(shape)
+    # New graph, new session WITHOUT warmstarting.
+    with ops.Graph().as_default() as g:
+      with self.test_session(graph=g) as sess:
+        cols_to_vars = self._create_linear_model([sc_vocab], partitioner)
+        sess.run(variables.global_variables_initializer())
+        # Without warmstarting, the weights should be initialized using default
+        # initializer (which is init_ops.zeros_initializer).
+        self._assert_cols_to_vars(cols_to_vars, {sc_vocab: [np.zeros([2, 1])]},
+                                  sess)
+
+    # New graph, new session with warmstarting.
+    with ops.Graph().as_default() as g:
+      with self.test_session(graph=g) as sess:
+        cols_to_vars = self._create_linear_model([sc_vocab], partitioner)
+        warmstart_settings = ws_util._WarmStartSettings(
+            ckpt_to_initialize_from=self.get_temp_dir(),
+            col_to_prev_vocab={
+                sc_vocab: (old_vocab_path, old_vocab_size)
+            })
+        ws_util._warmstart_input_layer(cols_to_vars, warmstart_settings)
+        sess.run(variables.global_variables_initializer())
+        # Verify weights were correctly warmstarted.  'banana' isn't in the
+        # first two entries of the old vocabulary, so it's newly initialized.
+        self._assert_cols_to_vars(cols_to_vars, {sc_vocab: [[[1], [0]]]}, sess)
+
   def testWarmStartInputLayer_BucketizedColumn(self):
     # Create feature column.
     real = fc.numeric_column("real")
diff --git a/tensorflow/python/framework/c_api_util.py b/tensorflow/python/framework/c_api_util.py
index ddababd5b8f0697594d86348875daada2a9896ba..1d0dd88dc5ce75504817eea9de9bf970a5660011 100644
--- a/tensorflow/python/framework/c_api_util.py
+++ b/tensorflow/python/framework/c_api_util.py
@@ -20,6 +20,7 @@ from __future__ import division
 from __future__ import print_function
 
 from tensorflow.python import pywrap_tensorflow as c_api
+from tensorflow.python.util import compat
 from tensorflow.python.util import tf_contextlib
 
 
@@ -49,22 +50,46 @@ class ScopedTFGraph(object):
       c_api.TF_DeleteGraph(self.graph)
 
 
+class ScopedTFImportGraphDefOptions(object):
+  """Wrapper around TF_ImportGraphDefOptions that handles deletion."""
+
+  def __init__(self):
+    self.options = c_api.TF_NewImportGraphDefOptions()
+
+  def __del__(self):
+    # Note: when we're destructing the global context (i.e when the process is
+    # terminating) we can have already deleted other modules.
+    if c_api.TF_DeleteImportGraphDefOptions is not None:
+      c_api.TF_DeleteImportGraphDefOptions(self.options)
+
+
 @tf_contextlib.contextmanager
-def tf_buffer():
+def tf_buffer(data=None):
   """Context manager that creates and deletes TF_Buffer.
 
   Example usage:
-    wtih tf_buffer() as buf:
+    with tf_buffer() as buf:
       # get serialized graph def into buf
       ...
       proto_data = c_api.TF_GetBuffer(buf)
       graph_def.ParseFromString(compat.as_bytes(proto_data))
     # buf has been deleted
 
+    with tf_buffer(some_string) as buf:
+      c_api.TF_SomeFunction(buf)
+    # buf has been deleted
+
+  Args:
+    data: An optional `bytes`, `str`, or `unicode` object. If not None, the
+      yielded buffer will contain this data.
+
   Yields:
     Created TF_Buffer
   """
-  buf = c_api.TF_NewBuffer()
+  if data:
+    buf = c_api.TF_NewBufferFromString(compat.as_bytes(data))
+  else:
+    buf = c_api.TF_NewBuffer()
   try:
     yield buf
   finally:
diff --git a/tensorflow/python/framework/graph_util_impl.py b/tensorflow/python/framework/graph_util_impl.py
index ce85747d7cf7fd3ee1803efe0260a90ef8e4b743..6c7b4553881637ce0b2ec63449bde0a397ef2d72 100644
--- a/tensorflow/python/framework/graph_util_impl.py
+++ b/tensorflow/python/framework/graph_util_impl.py
@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-
 """Helpers to manipulate a tensor graph in python.
 """
 
@@ -108,6 +107,46 @@ def _node_name(n):
     return n.split(":")[0]
 
 
+def _extract_graph_summary(graph_def):
+  """Extracts useful information from the graph and returns them."""
+  name_to_input_name = {}  # Keyed by the dest node name.
+  name_to_node = {}  # Keyed by node name.
+
+  # Keeps track of node sequences. It is important to still output the
+  # operations in the original order.
+  name_to_seq_num = {}  # Keyed by node name.
+  seq = 0
+  for node in graph_def.node:
+    n = _node_name(node.name)
+    name_to_node[n] = node
+    name_to_input_name[n] = [_node_name(x) for x in node.input]
+    name_to_seq_num[n] = seq
+    seq += 1
+  return name_to_input_name, name_to_node, name_to_seq_num
+
+
+def _assert_nodes_are_present(name_to_node, nodes):
+  """Assert that nodes are present in the graph."""
+  for d in nodes:
+    assert d in name_to_node, "%s is not in graph" % d
+
+
+def _bfs_for_reachable_nodes(target_nodes, name_to_input_name):
+  """Breadth first search for reachable nodes from target nodes."""
+  nodes_to_keep = set()
+  # Breadth first search to find all the nodes that we should keep.
+  next_to_visit = target_nodes[:]
+  while next_to_visit:
+    n = next_to_visit[0]
+    del next_to_visit[0]
+    if n in nodes_to_keep:
+      # Already visited this node.
+      continue
+    nodes_to_keep.add(n)
+    next_to_visit += name_to_input_name[n]
+  return nodes_to_keep
+
+
 def extract_sub_graph(graph_def, dest_nodes):
   """Extract the subgraph that can reach any of the nodes in 'dest_nodes'.
 
@@ -127,40 +166,18 @@ def extract_sub_graph(graph_def, dest_nodes):
   if isinstance(dest_nodes, six.string_types):
     raise TypeError("dest_nodes must be a list.")
 
-  edges = {}  # Keyed by the dest node name.
-  name_to_node_map = {}  # Keyed by node name.
-
-  # Keeps track of node sequences. It is important to still output the
-  # operations in the original order.
-  node_seq = {}  # Keyed by node name.
-  seq = 0
-  for node in graph_def.node:
-    n = _node_name(node.name)
-    name_to_node_map[n] = node
-    edges[n] = [_node_name(x) for x in node.input]
-    node_seq[n] = seq
-    seq += 1
-
-  for d in dest_nodes:
-    assert d in name_to_node_map, "%s is not in graph" % d
+  name_to_input_name, name_to_node, name_to_seq_num = _extract_graph_summary(
+      graph_def)
+  _assert_nodes_are_present(name_to_node, dest_nodes)
 
-  nodes_to_keep = set()
-  # Breadth first search to find all the nodes that we should keep.
-  next_to_visit = dest_nodes[:]
-  while next_to_visit:
-    n = next_to_visit[0]
-    del next_to_visit[0]
-    if n in nodes_to_keep:
-      # Already visited this node.
-      continue
-    nodes_to_keep.add(n)
-    next_to_visit += edges[n]
+  nodes_to_keep = _bfs_for_reachable_nodes(dest_nodes, name_to_input_name)
 
-  nodes_to_keep_list = sorted(list(nodes_to_keep), key=lambda n: node_seq[n])
+  nodes_to_keep_list = sorted(
+      list(nodes_to_keep), key=lambda n: name_to_seq_num[n])
   # Now construct the output GraphDef
   out = graph_pb2.GraphDef()
   for n in nodes_to_keep_list:
-    out.node.extend([copy.deepcopy(name_to_node_map[n])])
+    out.node.extend([copy.deepcopy(name_to_node[n])])
   out.library.CopyFrom(graph_def.library)
   out.versions.CopyFrom(graph_def.versions)
 
@@ -181,7 +198,9 @@ def tensor_shape_from_node_def_name(graph, input_name):
   return shape
 
 
-def convert_variables_to_constants(sess, input_graph_def, output_node_names,
+def convert_variables_to_constants(sess,
+                                   input_graph_def,
+                                   output_node_names,
                                    variable_names_whitelist=None,
                                    variable_names_blacklist=None):
   """Replaces all the variables in a graph with constants of the same values.
@@ -237,10 +256,10 @@ def convert_variables_to_constants(sess, input_graph_def, output_node_names,
       dtype = input_node.attr["dtype"]
       data = found_variables[input_node.name]
       output_node.attr["dtype"].CopyFrom(dtype)
-      output_node.attr["value"].CopyFrom(attr_value_pb2.AttrValue(
-          tensor=tensor_util.make_tensor_proto(data,
-                                               dtype=dtype.type,
-                                               shape=data.shape)))
+      output_node.attr["value"].CopyFrom(
+          attr_value_pb2.AttrValue(
+              tensor=tensor_util.make_tensor_proto(
+                  data, dtype=dtype.type, shape=data.shape)))
       how_many_converted += 1
     else:
       output_node.CopyFrom(input_node)
diff --git a/tensorflow/python/framework/importer.py b/tensorflow/python/framework/importer.py
index c6b335e6612cb6fda4982e149b957b46c4d94e2b..e4b94e1a344826ec8329e5de2da39de17a700e6c 100644
--- a/tensorflow/python/framework/importer.py
+++ b/tensorflow/python/framework/importer.py
@@ -25,8 +25,11 @@ import copy
 from tensorflow.core.framework import attr_value_pb2
 from tensorflow.core.framework import graph_pb2
 from tensorflow.core.framework import types_pb2
+from tensorflow.python import pywrap_tensorflow as c_api
+from tensorflow.python.framework import c_api_util
 from tensorflow.python.framework import device as pydev
 from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import errors
 from tensorflow.python.framework import function
 from tensorflow.python.framework import op_def_registry
 from tensorflow.python.framework import ops
@@ -242,12 +245,6 @@ def import_graph_def(graph_def, input_map=None, return_elements=None,
   input_map = _ProcessInputMapParam(input_map)
   return_elements = _ProcessReturnElementsParam(return_elements)
 
-  # Use a canonical representation for all tensor names.
-  input_map = {_CanonicalInputName(k): v for k, v in input_map.items()}
-  used_input_keys = set()
-
-  name_to_op = {}
-
   op_dict = op_def_registry.get_registered_ops()
 
   if producer_op_list is None:
@@ -255,10 +252,28 @@ def import_graph_def(graph_def, input_map=None, return_elements=None,
   else:
     producer_op_dict = {op.name: op for op in producer_op_list.op}
 
-  g = ops.get_default_graph()
-  if g._c_graph:  # pylint: disable=protected-access
-    assert 'import_graph_def not yet implemented with C API'
+  graph = ops.get_default_graph()
+
+  if graph._c_graph:  # pylint: disable=protected-access
+    scoped_options = c_api_util.ScopedTFImportGraphDefOptions()
+
+    with errors.raise_exception_on_not_ok_status() as status:
+      with c_api_util.tf_buffer(graph_def.SerializeToString()) as serialized:
+        c_api.TF_GraphImportGraphDefWithResults(
+            graph._c_graph, serialized, scoped_options.options, status)  # pylint: disable=protected-access
+
+    if return_elements is not None:
+      raise ValueError('return_elements not yet implemented with C API')
+    return None
+
   else:
+    g = graph
+
+    # Use a canonical representation for all tensor names.
+    input_map = {_CanonicalInputName(k): v for k, v in input_map.items()}
+    used_input_keys = set()
+    name_to_op = {}
+
     # Add any functions defined in `graph_def` to `g`
     if graph_def.library and graph_def.library.function:
       # Copy op_dict so we don't clobber the original
diff --git a/tensorflow/python/framework/importer_test.py b/tensorflow/python/framework/importer_test.py
index e447f9a3e8e659e4dc57fe0720635db7f8413031..d27ec1e30ca88ca9853c4e1f143396c0e332b07f 100644
--- a/tensorflow/python/framework/importer_test.py
+++ b/tensorflow/python/framework/importer_test.py
@@ -31,6 +31,7 @@ from tensorflow.python.framework import function
 from tensorflow.python.framework import importer
 from tensorflow.python.framework import ops
 from tensorflow.python.framework import test_ops  # pylint: disable=unused-import
+from tensorflow.python.framework import test_util
 from tensorflow.python.framework import versions
 from tensorflow.python.ops import array_ops
 from tensorflow.python.ops import gradients_impl
@@ -55,6 +56,28 @@ class ImportGraphDefTest(test.TestCase):
     text_format.Merge(text, ret)
     return ret
 
+  # The C API doesn't currently support return elements (or anything else beyond
+  # the most basic import). This test only checks that the import can run
+  # without error, and will be removed once more functionality is implemented
+  # and we can get coverage from the other tests.
+  @test_util.enable_c_api
+  def testCApi(self):
+    importer.import_graph_def(
+        self._MakeGraphDef("""
+        node { name: 'A' op: 'IntOutputFloatOutput' }
+          node { name: 'B' op: 'ListOutput'
+                 attr { key: 'T'
+                        value { list { type: DT_INT32 type: DT_FLOAT } } } }
+          node { name: 'C' op: 'ListInput'
+                 attr { key: 'N' value { i: 2 } }
+                 attr { key: 'T' value { type: DT_INT32 } }
+                 input: 'A:0' input: 'B:0' }
+          node { name: 'D' op: 'ListInput'
+                 attr { key: 'N' value { i: 2 } }
+                 attr { key: 'T' value { type: DT_FLOAT } }
+                 input: 'A:1' input: 'B:1' }
+          """))
+
   def testBasic(self):
     with ops.Graph().as_default():
       a, b, c, d = importer.import_graph_def(
@@ -108,6 +131,94 @@ class ImportGraphDefTest(test.TestCase):
       # Check that the op_def is still available.
       self.assertNotEqual(None, a.op_def)
 
+  def testMultipleImport(self):
+    graph_def = self._MakeGraphDef("""
+    node { name: 'A' op: 'IntOutput' }
+    node { name: 'B' op: 'IntInput' input: 'A:0' }
+    """)
+
+    with ops.Graph().as_default():
+      # Initial import
+      a, b = importer.import_graph_def(
+          graph_def,
+          return_elements=["A", "B"],
+          name="")
+      self.assertEqual(a.name, "A")
+      self.assertEqual(b.name, "B")
+      self.assertEqual(list(b.inputs), [a.outputs[0]])
+
+      # Repeat the same import
+      a1, b1 = importer.import_graph_def(
+          graph_def,
+          return_elements=["A", "B"],
+          name="")
+      self.assertEqual(a1.name, "A_1")
+      self.assertEqual(b1.name, "B_1")
+      self.assertEqual(list(b1.inputs), [a1.outputs[0]])
+
+      # Repeat the same import again
+      a2, b2 = importer.import_graph_def(
+          graph_def,
+          return_elements=["A", "B"],
+          name="")
+      self.assertEqual(a2.name, "A_2")
+      self.assertEqual(b2.name, "B_2")
+      self.assertEqual(list(b2.inputs), [a2.outputs[0]])
+
+      # Import with an already-used name
+      a3, b3 = importer.import_graph_def(
+          graph_def,
+          return_elements=["A", "B"],
+          name="A")
+      self.assertEqual(a3.name, "A_3/A")
+      self.assertEqual(b3.name, "A_3/B")
+      self.assertEqual(list(b3.inputs), [a3.outputs[0]])
+
+      # Import with existing de-duped node names
+      a4, b4 = importer.import_graph_def(
+          self._MakeGraphDef("""
+          node { name: 'A_1' op: 'IntOutput' }
+          node { name: 'B_1' op: 'IntInput' input: 'A_1:0' }
+          """),
+          return_elements=["A_1", "B_1"],
+          name="")
+      self.assertEqual(a4.name, "A_1_1")
+      self.assertEqual(b4.name, "B_1_1")
+      self.assertEqual(list(b4.inputs), [a4.outputs[0]])
+
+      # Create a name scope and then import node with same name
+      with ops.name_scope("foo"):
+        constant_op.constant(1)
+      foo, = importer.import_graph_def(
+          self._MakeGraphDef("node { name: 'foo' op: 'IntOutput' }"),
+          return_elements=["foo"],
+          name="")
+      self.assertEqual(foo.name, "foo_1")
+
+      # Imported node name can't conflict with intermediate name scope (but can
+      # conflict with outer scope and full name scope)
+      with ops.name_scope("outer"):
+        with ops.name_scope("inner"):
+          c = constant_op.constant(1, name="c")
+          self.assertEqual(c.op.name, "outer/inner/c")
+
+      outer, inner, new_c, outer_inner, outer_inner_c = (
+          importer.import_graph_def(
+              self._MakeGraphDef(
+                  "node { name: 'outer' op: 'IntOutput' }"
+                  "node { name: 'inner' op: 'IntOutput' }"
+                  "node { name: 'c' op: 'IntOutput' }"
+                  "node { name: 'outer/inner' op: 'IntOutput' }"
+                  "node { name: 'outer/inner/c' op: 'IntOutput' }"),
+              return_elements=["outer", "inner", "c", "outer/inner",
+                               "outer/inner/c"],
+              name=""))
+      self.assertEqual(outer.name, "outer_1")
+      self.assertEqual(inner.name, "inner")
+      self.assertEqual(new_c.name, "c")
+      self.assertEqual(outer_inner.name, "outer/inner_1")
+      self.assertEqual(outer_inner_c.name, "outer/inner/c_1")
+
   def testInputMap(self):
     with ops.Graph().as_default():
       feed_a_0 = constant_op.constant(0, dtype=dtypes.int32)
diff --git a/tensorflow/python/framework/ops.py b/tensorflow/python/framework/ops.py
index 95274374adecb5e3ff426bbb29b1035d4475699e..6469aca3ec2363c12f62e41187def24b135c8536 100644
--- a/tensorflow/python/framework/ops.py
+++ b/tensorflow/python/framework/ops.py
@@ -2952,7 +2952,11 @@ class Graph(object):
         if previous._hash_str == function._hash_str:
           return
         else:
-          raise ValueError("Another function is already defined with that name")
+          raise ValueError("Cannot add function (%s, hash %s) to graph (%s). "
+                           "Another function (%s, hash %s) is already defined "
+                           "with that name (%s)" % (
+                               function, function._hash_str, self,
+                               previous, previous._hash_str, name))
     # pylint: enable=protected-access
 
     self._functions[name] = function
diff --git a/tensorflow/python/framework/test_util.py b/tensorflow/python/framework/test_util.py
index dbe9a2421c95a5b4cf654e0e3113f2c62fd26518..6e3a35af3cd55f86034afb438efc2be6ae06f131 100644
--- a/tensorflow/python/framework/test_util.py
+++ b/tensorflow/python/framework/test_util.py
@@ -20,6 +20,7 @@ from __future__ import division
 from __future__ import print_function
 
 import contextlib
+import gc
 import math
 import random
 import re
@@ -452,9 +453,43 @@ class IsolateTest(object):
         type_arg, value_arg, traceback_arg)
 
 
-def run_in_graph_and_eager_modes(__unused__=None, graph=None, config=None,
-                                 use_gpu=False, force_gpu=False,
-                                 reset_test=True):
+def assert_no_garbage_created(f):
+  """Test method decorator to assert that no garbage has been created.
+
+  Note that this decorator sets DEBUG_SAVEALL, which in some Python interpreters
+  cannot be un-set (i.e. will disable garbage collection for any other unit
+  tests in the same file/shard).
+
+  Args:
+    f: The function to decorate.
+  Returns:
+    The decorated function.
+  """
+
+  def decorator(self, **kwargs):
+    """Sets DEBUG_SAVEALL, runs the test, and checks for new garbage."""
+    gc.disable()
+    previous_debug_flags = gc.get_debug()
+    gc.set_debug(gc.DEBUG_SAVEALL)
+    gc.collect()
+    previous_garbage = len(gc.garbage)
+    f(self, **kwargs)
+    gc.collect()
+    # This will fail if any garbage has been created, typically because of a
+    # reference cycle.
+    self.assertEqual(previous_garbage, len(gc.garbage))
+    # TODO(allenl): Figure out why this debug flag reset doesn't work. It would
+    # be nice to be able to decorate arbitrary tests in a large test suite and
+    # not hold on to every object in other tests.
+    gc.set_debug(previous_debug_flags)
+    gc.enable()
+  return decorator
+
+
+def run_in_graph_and_eager_modes(
+    __unused__=None, graph=None, config=None,
+    use_gpu=False, force_gpu=False,
+    reset_test=True, assert_no_eager_garbage=False):
   """Runs the test in both graph and eager modes.
 
   Args:
@@ -465,7 +500,14 @@ def run_in_graph_and_eager_modes(__unused__=None, graph=None, config=None,
     use_gpu: If True, attempt to run as many ops as possible on GPU.
     force_gpu: If True, pin all ops to `/device:GPU:0`.
     reset_test: If True, tearDown and SetUp the test case again.
-
+    assert_no_eager_garbage: If True, sets DEBUG_SAVEALL on the garbage
+      collector and asserts that no extra garbage has been created when running
+      the test in eager mode. This will fail if there are reference cycles
+      (e.g. a = []; a.append(a)). Off by default because some tests may create
+      garbage for legitimate reasons (e.g. they define a class which inherits
+      from `object`), and because DEBUG_SAVEALL is sticky in some Python
+      interpreters (meaning that tests which rely on objects being collected
+      elsewhere in the unit test file will not work).
   Returns:
     Returns a decorator that will run the decorated test function
         using both a graph and using eager execution.
@@ -487,7 +529,7 @@ def run_in_graph_and_eager_modes(__unused__=None, graph=None, config=None,
         self.tearDown()
         self.setUp()
 
-      def run_eager_mode():
+      def run_eager_mode(self, **kwargs):
         if force_gpu:
           gpu_name = gpu_device_name()
           if not gpu_name:
@@ -501,9 +543,12 @@ def run_in_graph_and_eager_modes(__unused__=None, graph=None, config=None,
           with context.device("/device:CPU:0"):
             f(self, **kwargs)
 
+      if assert_no_eager_garbage:
+        run_eager_mode = assert_no_garbage_created(run_eager_mode)
+
       with context.eager_mode():
         with IsolateTest():
-          run_eager_mode()
+          run_eager_mode(self, **kwargs)
 
     return decorated
   return decorator
diff --git a/tensorflow/python/framework/test_util_test.py b/tensorflow/python/framework/test_util_test.py
index b2f8d62095f75ba55344a63401525ea998a70b47..1c5db945005b6a8c1006dc75c2f1507b2ecb3077 100644
--- a/tensorflow/python/framework/test_util_test.py
+++ b/tensorflow/python/framework/test_util_test.py
@@ -329,6 +329,30 @@ class TestUtilTest(test_util.TensorFlowTestCase):
     self.assertEqual(a_rand, b_rand)
 
 
+class GarbageCollectionTest(test_util.TensorFlowTestCase):
+
+  def test_no_reference_cycle_decorator(self):
+
+    class ReferenceCycleTest(object):
+
+      def __init__(inner_self):  # pylint: disable=no-self-argument
+        inner_self.assertEqual = self.assertEqual  # pylint: disable=invalid-name
+
+      @test_util.assert_no_garbage_created
+      def test_has_cycle(self):
+        a = []
+        a.append(a)
+
+      @test_util.assert_no_garbage_created
+      def test_has_no_cycle(self):
+        pass
+
+    with self.assertRaises(AssertionError):
+      ReferenceCycleTest().test_has_cycle()
+
+    ReferenceCycleTest().test_has_no_cycle()
+
+
 @test_util.with_c_api
 class IsolationTest(test_util.TensorFlowTestCase):
 
diff --git a/tensorflow/python/grappler/layout_optimizer_test.py b/tensorflow/python/grappler/layout_optimizer_test.py
index bda9502cd115eaca0df06e80ee716726d91f13c4..87f07c4a525e5e162372626290286068af8746eb 100644
--- a/tensorflow/python/grappler/layout_optimizer_test.py
+++ b/tensorflow/python/grappler/layout_optimizer_test.py
@@ -23,12 +23,18 @@ from tensorflow.core.protobuf import rewriter_config_pb2
 from tensorflow.python.client import session
 from tensorflow.python.framework import constant_op
 from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
 from tensorflow.python.framework import random_seed
+from tensorflow.python.grappler import tf_optimizer
+from tensorflow.python.layers import convolutional as conv_layers
 from tensorflow.python.ops import array_ops
 from tensorflow.python.ops import functional_ops
+from tensorflow.python.ops import math_ops
 from tensorflow.python.ops import nn
 from tensorflow.python.ops import random_ops
 from tensorflow.python.platform import test
+from tensorflow.python.training import gradient_descent
+from tensorflow.python.training import saver
 
 
 def weight(shape):
@@ -133,6 +139,32 @@ class LayoutOptimizerTest(test.TestCase):
 
       self.assertAllClose(output_val_ref, output_val, atol=1e-3)
 
+  def testGradient(self):
+    if not test.is_gpu_available(cuda_only=True):
+      self.skipTest('GPU required')
+
+    random_seed.set_random_seed(0)
+    x = random_ops.truncated_normal([1, 200, 200, 3], seed=0)
+    y = conv_layers.conv2d(x, 32, [3, 3])
+    z = conv_layers.conv2d(y, 32, [3, 3])
+    optimizer = gradient_descent.GradientDescentOptimizer(1e-4)
+    loss = math_ops.reduce_mean(z)
+    train_op = optimizer.minimize(loss)
+    graph = ops.get_default_graph()
+    graph.add_to_collection('train_op', train_op)
+    meta_graph = saver.export_meta_graph(graph_def=graph.as_graph_def())
+
+    rewrite_options = rewriter_config_pb2.RewriterConfig(
+        optimize_tensor_layout=True)
+    optimized_graph = tf_optimizer.OptimizeGraph(rewrite_options, meta_graph)
+
+    found = 0
+    for node in optimized_graph.node:
+      if node.op in ['Conv2D', 'Conv2DBackpropFilter', 'Conv2DBackpropInput']:
+        found += 1
+        self.assertEqual(node.attr['data_format'].s, 'NCHW')
+    self.assertEqual(found, 5)
+
 
 if __name__ == '__main__':
   test.main()
diff --git a/tensorflow/python/grappler/tf_optimizer.i b/tensorflow/python/grappler/tf_optimizer.i
index 09c19cb1867954ffd83fde6e24620e93becae886..f3d8fe194b848f94037044b5d3b5e2d8ebe01d1c 100644
--- a/tensorflow/python/grappler/tf_optimizer.i
+++ b/tensorflow/python/grappler/tf_optimizer.i
@@ -104,8 +104,9 @@ PyObject* TF_OptimizeGraph(
     tensorflow::DeviceBase* cpu_device = nullptr;
     tensorflow::grappler::VirtualCluster cluster(device_map);
     tensorflow::GraphDef out_graph;
-    tensorflow::Status status = tensorflow::grappler::RunMetaOptimizer(
-        *grappler_item, rewriter_config, cpu_device, &cluster, &out_graph);
+    tensorflow::grappler::MetaOptimizer optimizer(cpu_device, rewriter_config);
+    tensorflow::Status status = optimizer.Optimize(&cluster, *grappler_item, &out_graph);
+    optimizer.PrintResult();
     tensorflow::Set_TF_Status_from_Status(out_status, status);
     string out_graph_str = out_graph.SerializeAsString();
     PyObject* ret = PyBytes_FromStringAndSize(out_graph_str.data(),
diff --git a/tensorflow/python/keras/BUILD b/tensorflow/python/keras/BUILD
index d61733dff6f0173883bf0b0b1cf416014f8546c8..4db48b45edd86fb3e4a991a9a8302dfb9276a087 100644
--- a/tensorflow/python/keras/BUILD
+++ b/tensorflow/python/keras/BUILD
@@ -15,6 +15,7 @@ py_library(
         "_impl/keras/activations.py",
         "_impl/keras/applications/__init__.py",
         "_impl/keras/applications/imagenet_utils.py",
+        "_impl/keras/applications/inception_resnet_v2.py",
         "_impl/keras/applications/inception_v3.py",
         "_impl/keras/applications/mobilenet.py",
         "_impl/keras/applications/resnet50.py",
@@ -73,6 +74,7 @@ py_library(
         "_impl/keras/wrappers/scikit_learn.py",
         "activations/__init__.py",
         "applications/__init__.py",
+        "applications/inception_resnet_v2/__init__.py",
         "applications/inception_v3/__init__.py",
         "applications/mobilenet/__init__.py",
         "applications/resnet50/__init__.py",
@@ -250,6 +252,18 @@ py_test(
     ],
 )
 
+py_test(
+    name = "inception_resnet_v2_test",
+    size = "medium",
+    srcs = ["_impl/keras/applications/inception_resnet_v2_test.py"],
+    srcs_version = "PY2AND3",
+    deps = [
+        ":keras",
+        "//tensorflow/python:client_testlib",
+        "//third_party/py/numpy",
+    ],
+)
+
 py_test(
     name = "inception_v3_test",
     size = "medium",
diff --git a/tensorflow/python/keras/__init__.py b/tensorflow/python/keras/__init__.py
index fa79889966504130f17baa1b94e40d17069cbb01..f56be967ff5c066c1b119aed1ed8813490d2b045 100644
--- a/tensorflow/python/keras/__init__.py
+++ b/tensorflow/python/keras/__init__.py
@@ -42,6 +42,8 @@ from tensorflow.python.keras import utils
 from tensorflow.python.keras import wrappers
 from tensorflow.python.keras._impl.keras import __version__
 from tensorflow.python.keras.layers import Input
+from tensorflow.python.keras.models import Model
+from tensorflow.python.keras.models import Sequential
 
 del absolute_import
 del division
diff --git a/tensorflow/python/keras/_impl/keras/__init__.py b/tensorflow/python/keras/_impl/keras/__init__.py
index a341065100d2116d76c004baa5120fa10a10e8fc..f0e8d91a9290ed13cd8d39e8e549af59a8c2d253 100644
--- a/tensorflow/python/keras/_impl/keras/__init__.py
+++ b/tensorflow/python/keras/_impl/keras/__init__.py
@@ -37,5 +37,7 @@ from tensorflow.python.keras._impl.keras import regularizers
 from tensorflow.python.keras._impl.keras import utils
 from tensorflow.python.keras._impl.keras import wrappers
 from tensorflow.python.keras._impl.keras.layers import Input
+from tensorflow.python.keras._impl.keras.models import Model
+from tensorflow.python.keras._impl.keras.models import Sequential
 
 __version__ = '2.0.8-tf'
diff --git a/tensorflow/python/keras/_impl/keras/applications/__init__.py b/tensorflow/python/keras/_impl/keras/applications/__init__.py
index f78bbdc148145591cc16e3231bd9d2b7c06d208b..c11c52b71e9bff1cfd595a9dbc0e86dcaa8506c8 100644
--- a/tensorflow/python/keras/_impl/keras/applications/__init__.py
+++ b/tensorflow/python/keras/_impl/keras/applications/__init__.py
@@ -18,6 +18,7 @@ from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
+from tensorflow.python.keras._impl.keras.applications.inception_resnet_v2 import InceptionResNetV2
 from tensorflow.python.keras._impl.keras.applications.inception_v3 import InceptionV3
 from tensorflow.python.keras._impl.keras.applications.mobilenet import MobileNet
 from tensorflow.python.keras._impl.keras.applications.resnet50 import ResNet50
diff --git a/tensorflow/python/keras/_impl/keras/applications/imagenet_utils.py b/tensorflow/python/keras/_impl/keras/applications/imagenet_utils.py
index 43628341cb522090caf6eb996a5f0c9b44488424..58841e5db06229727ea088388a901633216aa6fe 100644
--- a/tensorflow/python/keras/_impl/keras/applications/imagenet_utils.py
+++ b/tensorflow/python/keras/_impl/keras/applications/imagenet_utils.py
@@ -29,12 +29,19 @@ CLASS_INDEX = None
 CLASS_INDEX_PATH = 'https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json'
 
 
-def preprocess_input(x, data_format=None):
+def preprocess_input(x, data_format=None, mode='caffe'):
   """Preprocesses a tensor encoding a batch of images.
 
   Arguments:
       x: input Numpy tensor, 4D.
       data_format: data format of the image tensor.
+      mode: One of "caffe", "tf".
+          - caffe: will convert the images from RGB to BGR,
+              then will zero-center each color channel with
+              respect to the ImageNet dataset,
+              without scaling.
+          - tf: will scale pixels between -1 and 1,
+              sample-wise.
 
   Returns:
       Preprocessed tensor.
@@ -43,6 +50,12 @@ def preprocess_input(x, data_format=None):
     data_format = K.image_data_format()
   assert data_format in {'channels_last', 'channels_first'}
 
+  if mode == 'tf':
+    x /= 255.
+    x -= 0.5
+    x *= 2.
+    return x
+
   if data_format == 'channels_first':
     if x.ndim == 3:
       # 'RGB'->'BGR'
@@ -89,8 +102,10 @@ def decode_predictions(preds, top=5):
                      '(i.e. a 2D array of shape (samples, 1000)). '
                      'Found array with shape: ' + str(preds.shape))
   if CLASS_INDEX is None:
-    fpath = get_file(
-        'imagenet_class_index.json', CLASS_INDEX_PATH, cache_subdir='models')
+    fpath = get_file('imagenet_class_index.json',
+                     CLASS_INDEX_PATH,
+                     cache_subdir='models',
+                     file_hash='c2c37ea517e94d9795004a39431a14cb')
     CLASS_INDEX = json.load(open(fpath))
   results = []
   for pred in preds:
diff --git a/tensorflow/python/keras/_impl/keras/applications/inception_resnet_v2.py b/tensorflow/python/keras/_impl/keras/applications/inception_resnet_v2.py
new file mode 100644
index 0000000000000000000000000000000000000000..de29b92575e48410614d3b32520d99436891344a
--- /dev/null
+++ b/tensorflow/python/keras/_impl/keras/applications/inception_resnet_v2.py
@@ -0,0 +1,369 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Inception-ResNet V2 model for Keras.
+
+# Reference
+- [Inception-v4, Inception-ResNet and the Impact of
+   Residual Connections on Learning](https://arxiv.org/abs/1602.07261)
+
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from tensorflow.python.keras._impl.keras import backend as K
+from tensorflow.python.keras._impl.keras.applications import imagenet_utils
+from tensorflow.python.keras._impl.keras.applications.imagenet_utils import _obtain_input_shape
+from tensorflow.python.keras._impl.keras.applications.imagenet_utils import decode_predictions  # pylint: disable=unused-import
+from tensorflow.python.keras._impl.keras.engine.topology import get_source_inputs
+from tensorflow.python.keras._impl.keras.layers import Activation
+from tensorflow.python.keras._impl.keras.layers import AveragePooling2D
+from tensorflow.python.keras._impl.keras.layers import BatchNormalization
+from tensorflow.python.keras._impl.keras.layers import Concatenate
+from tensorflow.python.keras._impl.keras.layers import Conv2D
+from tensorflow.python.keras._impl.keras.layers import Dense
+from tensorflow.python.keras._impl.keras.layers import GlobalAveragePooling2D
+from tensorflow.python.keras._impl.keras.layers import GlobalMaxPooling2D
+from tensorflow.python.keras._impl.keras.layers import Input
+from tensorflow.python.keras._impl.keras.layers import Lambda
+from tensorflow.python.keras._impl.keras.layers import MaxPooling2D
+from tensorflow.python.keras._impl.keras.models import Model
+from tensorflow.python.keras._impl.keras.utils.data_utils import get_file
+
+BASE_WEIGHT_URL = 'https://github.com/fchollet/deep-learning-models/releases/download/v0.7/'
+
+
+def preprocess_input(x):
+  """Preprocesses a numpy array encoding a batch of images.
+
+  Arguments:
+      x: a 4D numpy array consists of RGB values within [0, 255].
+
+  Returns:
+      Preprocessed array.
+  """
+  return imagenet_utils.preprocess_input(x, mode='tf')
+
+
+def conv2d_bn(x,
+              filters,
+              kernel_size,
+              strides=1,
+              padding='same',
+              activation='relu',
+              use_bias=False,
+              name=None):
+  """Utility function to apply conv + BN.
+
+  Arguments:
+      x: input tensor.
+      filters: filters in `Conv2D`.
+      kernel_size: kernel size as in `Conv2D`.
+      strides: strides in `Conv2D`.
+      padding: padding mode in `Conv2D`.
+      activation: activation in `Conv2D`.
+      use_bias: whether to use a bias in `Conv2D`.
+      name: name of the ops; will become `name + '_ac'` for the activation
+          and `name + '_bn'` for the batch norm layer.
+
+  Returns:
+      Output tensor after applying `Conv2D` and `BatchNormalization`.
+  """
+  x = Conv2D(
+      filters,
+      kernel_size,
+      strides=strides,
+      padding=padding,
+      use_bias=use_bias,
+      name=name)(
+          x)
+  if not use_bias:
+    bn_axis = 1 if K.image_data_format() == 'channels_first' else 3
+    bn_name = None if name is None else name + '_bn'
+    x = BatchNormalization(axis=bn_axis, scale=False, name=bn_name)(x)
+  if activation is not None:
+    ac_name = None if name is None else name + '_ac'
+    x = Activation(activation, name=ac_name)(x)
+  return x
+
+
+def inception_resnet_block(x, scale, block_type, block_idx, activation='relu'):
+  """Adds a Inception-ResNet block.
+
+  This function builds 3 types of Inception-ResNet blocks mentioned
+  in the paper, controlled by the `block_type` argument (which is the
+  block name used in the official TF-slim implementation):
+      - Inception-ResNet-A: `block_type='block35'`
+      - Inception-ResNet-B: `block_type='block17'`
+      - Inception-ResNet-C: `block_type='block8'`
+
+  Arguments:
+      x: input tensor.
+      scale: scaling factor to scale the residuals (i.e., the output of
+          passing `x` through an inception module) before adding them
+          to the shortcut branch. Let `r` be the output from the residual
+          branch, the output of this block will be `x + scale * r`.
+      block_type: `'block35'`, `'block17'` or `'block8'`, determines
+          the network structure in the residual branch.
+      block_idx: an `int` used for generating layer names. The Inception-ResNet
+        blocks
+          are repeated many times in this network. We use `block_idx` to
+            identify
+          each of the repetitions. For example, the first Inception-ResNet-A
+            block
+          will have `block_type='block35', block_idx=0`, ane the layer names
+            will have
+          a common prefix `'block35_0'`.
+      activation: activation function to use at the end of the block
+          (see [activations](../activations.md)).
+          When `activation=None`, no activation is applied
+          (i.e., "linear" activation: `a(x) = x`).
+
+  Returns:
+      Output tensor for the block.
+
+  Raises:
+      ValueError: if `block_type` is not one of `'block35'`,
+          `'block17'` or `'block8'`.
+  """
+  if block_type == 'block35':
+    branch_0 = conv2d_bn(x, 32, 1)
+    branch_1 = conv2d_bn(x, 32, 1)
+    branch_1 = conv2d_bn(branch_1, 32, 3)
+    branch_2 = conv2d_bn(x, 32, 1)
+    branch_2 = conv2d_bn(branch_2, 48, 3)
+    branch_2 = conv2d_bn(branch_2, 64, 3)
+    branches = [branch_0, branch_1, branch_2]
+  elif block_type == 'block17':
+    branch_0 = conv2d_bn(x, 192, 1)
+    branch_1 = conv2d_bn(x, 128, 1)
+    branch_1 = conv2d_bn(branch_1, 160, [1, 7])
+    branch_1 = conv2d_bn(branch_1, 192, [7, 1])
+    branches = [branch_0, branch_1]
+  elif block_type == 'block8':
+    branch_0 = conv2d_bn(x, 192, 1)
+    branch_1 = conv2d_bn(x, 192, 1)
+    branch_1 = conv2d_bn(branch_1, 224, [1, 3])
+    branch_1 = conv2d_bn(branch_1, 256, [3, 1])
+    branches = [branch_0, branch_1]
+  else:
+    raise ValueError('Unknown Inception-ResNet block type. '
+                     'Expects "block35", "block17" or "block8", '
+                     'but got: ' + str(block_type))
+
+  block_name = block_type + '_' + str(block_idx)
+  channel_axis = 1 if K.image_data_format() == 'channels_first' else 3
+  mixed = Concatenate(axis=channel_axis, name=block_name + '_mixed')(branches)
+  up = conv2d_bn(
+      mixed,
+      K.int_shape(x)[channel_axis],
+      1,
+      activation=None,
+      use_bias=True,
+      name=block_name + '_conv')
+
+  x = Lambda(
+      lambda inputs, scale: inputs[0] + inputs[1] * scale,
+      arguments={'scale': scale},
+      name=block_name)([x, up])
+  if activation is not None:
+    x = Activation(activation, name=block_name + '_ac')(x)
+  return x
+
+
+def InceptionResNetV2(include_top=True,  # pylint: disable=invalid-name
+                      weights='imagenet',
+                      input_tensor=None,
+                      input_shape=None,
+                      pooling=None,
+                      classes=1000):
+  """Instantiates the Inception-ResNet v2 architecture.
+
+  Optionally loads weights pre-trained on ImageNet.
+  Note that when using TensorFlow, for best performance you should
+  set `"image_data_format": "channels_last"` in your Keras config
+  at `~/.keras/keras.json`.
+
+  The model and the weights are compatible with TensorFlow, Theano and
+  CNTK backends. The data format convention used by the model is
+  the one specified in your Keras config file.
+
+  Note that the default input image size for this model is 299x299, instead
+  of 224x224 as in the VGG16 and ResNet models. Also, the input preprocessing
+  function is different (i.e., do not use `imagenet_utils.preprocess_input()`
+  with this model. Use `preprocess_input()` defined in this module instead).
+
+  Arguments:
+      include_top: whether to include the fully-connected
+          layer at the top of the network.
+      weights: one of `None` (random initialization)
+          or `'imagenet'` (pre-training on ImageNet).
+      input_tensor: optional Keras tensor (i.e. output of `layers.Input()`)
+          to use as image input for the model.
+      input_shape: optional shape tuple, only to be specified
+          if `include_top` is `False` (otherwise the input shape
+          has to be `(299, 299, 3)` (with `'channels_last'` data format)
+          or `(3, 299, 299)` (with `'channels_first'` data format).
+          It should have exactly 3 inputs channels,
+          and width and height should be no smaller than 139.
+          E.g. `(150, 150, 3)` would be one valid value.
+      pooling: Optional pooling mode for feature extraction
+          when `include_top` is `False`.
+          - `None` means that the output of the model will be
+              the 4D tensor output of the last convolutional layer.
+          - `'avg'` means that global average pooling
+              will be applied to the output of the
+              last convolutional layer, and thus
+              the output of the model will be a 2D tensor.
+          - `'max'` means that global max pooling will be applied.
+      classes: optional number of classes to classify images
+          into, only to be specified if `include_top` is `True`, and
+          if no `weights` argument is specified.
+
+  Returns:
+      A Keras `Model` instance.
+
+  Raises:
+      ValueError: in case of invalid argument for `weights`,
+          or invalid input shape.
+  """
+  if weights not in {'imagenet', None}:
+    raise ValueError('The `weights` argument should be either '
+                     '`None` (random initialization) or `imagenet` '
+                     '(pre-training on ImageNet).')
+
+  if weights == 'imagenet' and include_top and classes != 1000:
+    raise ValueError('If using `weights` as imagenet with `include_top`'
+                     ' as true, `classes` should be 1000')
+
+  # Determine proper input shape
+  input_shape = _obtain_input_shape(
+      input_shape,
+      default_size=299,
+      min_size=139,
+      data_format=K.image_data_format(),
+      require_flatten=False,
+      weights=weights)
+
+  if input_tensor is None:
+    img_input = Input(shape=input_shape)
+  else:
+    if not K.is_keras_tensor(input_tensor):
+      img_input = Input(tensor=input_tensor, shape=input_shape)
+    else:
+      img_input = input_tensor
+
+  # Stem block: 35 x 35 x 192
+  x = conv2d_bn(img_input, 32, 3, strides=2, padding='valid')
+  x = conv2d_bn(x, 32, 3, padding='valid')
+  x = conv2d_bn(x, 64, 3)
+  x = MaxPooling2D(3, strides=2)(x)
+  x = conv2d_bn(x, 80, 1, padding='valid')
+  x = conv2d_bn(x, 192, 3, padding='valid')
+  x = MaxPooling2D(3, strides=2)(x)
+
+  # Mixed 5b (Inception-A block): 35 x 35 x 320
+  branch_0 = conv2d_bn(x, 96, 1)
+  branch_1 = conv2d_bn(x, 48, 1)
+  branch_1 = conv2d_bn(branch_1, 64, 5)
+  branch_2 = conv2d_bn(x, 64, 1)
+  branch_2 = conv2d_bn(branch_2, 96, 3)
+  branch_2 = conv2d_bn(branch_2, 96, 3)
+  branch_pool = AveragePooling2D(3, strides=1, padding='same')(x)
+  branch_pool = conv2d_bn(branch_pool, 64, 1)
+  branches = [branch_0, branch_1, branch_2, branch_pool]
+  channel_axis = 1 if K.image_data_format() == 'channels_first' else 3
+  x = Concatenate(axis=channel_axis, name='mixed_5b')(branches)
+
+  # 10x block35 (Inception-ResNet-A block): 35 x 35 x 320
+  for block_idx in range(1, 11):
+    x = inception_resnet_block(
+        x, scale=0.17, block_type='block35', block_idx=block_idx)
+
+  # Mixed 6a (Reduction-A block): 17 x 17 x 1088
+  branch_0 = conv2d_bn(x, 384, 3, strides=2, padding='valid')
+  branch_1 = conv2d_bn(x, 256, 1)
+  branch_1 = conv2d_bn(branch_1, 256, 3)
+  branch_1 = conv2d_bn(branch_1, 384, 3, strides=2, padding='valid')
+  branch_pool = MaxPooling2D(3, strides=2, padding='valid')(x)
+  branches = [branch_0, branch_1, branch_pool]
+  x = Concatenate(axis=channel_axis, name='mixed_6a')(branches)
+
+  # 20x block17 (Inception-ResNet-B block): 17 x 17 x 1088
+  for block_idx in range(1, 21):
+    x = inception_resnet_block(
+        x, scale=0.1, block_type='block17', block_idx=block_idx)
+
+  # Mixed 7a (Reduction-B block): 8 x 8 x 2080
+  branch_0 = conv2d_bn(x, 256, 1)
+  branch_0 = conv2d_bn(branch_0, 384, 3, strides=2, padding='valid')
+  branch_1 = conv2d_bn(x, 256, 1)
+  branch_1 = conv2d_bn(branch_1, 288, 3, strides=2, padding='valid')
+  branch_2 = conv2d_bn(x, 256, 1)
+  branch_2 = conv2d_bn(branch_2, 288, 3)
+  branch_2 = conv2d_bn(branch_2, 320, 3, strides=2, padding='valid')
+  branch_pool = MaxPooling2D(3, strides=2, padding='valid')(x)
+  branches = [branch_0, branch_1, branch_2, branch_pool]
+  x = Concatenate(axis=channel_axis, name='mixed_7a')(branches)
+
+  # 10x block8 (Inception-ResNet-C block): 8 x 8 x 2080
+  for block_idx in range(1, 10):
+    x = inception_resnet_block(
+        x, scale=0.2, block_type='block8', block_idx=block_idx)
+  x = inception_resnet_block(
+      x, scale=1., activation=None, block_type='block8', block_idx=10)
+
+  # Final convolution block: 8 x 8 x 1536
+  x = conv2d_bn(x, 1536, 1, name='conv_7b')
+
+  if include_top:
+    # Classification block
+    x = GlobalAveragePooling2D(name='avg_pool')(x)
+    x = Dense(classes, activation='softmax', name='predictions')(x)
+  else:
+    if pooling == 'avg':
+      x = GlobalAveragePooling2D()(x)
+    elif pooling == 'max':
+      x = GlobalMaxPooling2D()(x)
+
+  # Ensure that the model takes into account
+  # any potential predecessors of `input_tensor`
+  if input_tensor is not None:
+    inputs = get_source_inputs(input_tensor)
+  else:
+    inputs = img_input
+
+  # Create model
+  model = Model(inputs, x, name='inception_resnet_v2')
+
+  # Load weights
+  if weights == 'imagenet':
+    if include_top:
+      fname = 'inception_resnet_v2_weights_tf_dim_ordering_tf_kernels.h5'
+      weights_path = get_file(
+          fname,
+          BASE_WEIGHT_URL + fname,
+          cache_subdir='models',
+          file_hash='e693bd0210a403b3192acc6073ad2e96')
+    else:
+      fname = 'inception_resnet_v2_weights_tf_dim_ordering_tf_kernels_notop.h5'
+      weights_path = get_file(
+          fname,
+          BASE_WEIGHT_URL + fname,
+          cache_subdir='models',
+          file_hash='d19885ff4a710c122648d3b5c3b684e4')
+    model.load_weights(weights_path)
+
+  return model
diff --git a/tensorflow/python/keras/_impl/keras/applications/inception_resnet_v2_test.py b/tensorflow/python/keras/_impl/keras/applications/inception_resnet_v2_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..de71e9615a09ecdf07a51fff0b3ee3b1d8ca50ca
--- /dev/null
+++ b/tensorflow/python/keras/_impl/keras/applications/inception_resnet_v2_test.py
@@ -0,0 +1,59 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for Inception V3 application."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+
+from tensorflow.python.keras._impl import keras
+from tensorflow.python.platform import test
+
+
+class InceptionResNetV2Test(test.TestCase):
+
+  def test_with_top(self):
+    model = keras.applications.InceptionResNetV2(weights=None)
+    self.assertEqual(model.output_shape, (None, 1000))
+
+  def test_no_top(self):
+    model = keras.applications.InceptionResNetV2(weights=None,
+                                                 include_top=False)
+    self.assertEqual(model.output_shape, (None, None, None, 1536))
+
+  def test_with_pooling(self):
+    model = keras.applications.InceptionResNetV2(weights=None,
+                                                 include_top=False,
+                                                 pooling='avg')
+    self.assertEqual(model.output_shape, (None, 1536))
+
+  def test_weight_loading(self):
+    with self.assertRaises(ValueError):
+      keras.applications.InceptionResNetV2(weights='unknown',
+                                           include_top=False)
+    with self.assertRaises(ValueError):
+      keras.applications.InceptionResNetV2(weights='imagenet',
+                                           classes=2000)
+
+  def test_preprocess_input(self):
+    x = np.random.uniform(0, 255, (2, 300, 200, 3))
+    out1 = keras.applications.inception_resnet_v2.preprocess_input(x)
+    self.assertAllClose(np.mean(out1), 0., atol=0.1)
+
+
+if __name__ == '__main__':
+  test.main()
diff --git a/tensorflow/python/keras/_impl/keras/applications/inception_v3.py b/tensorflow/python/keras/_impl/keras/applications/inception_v3.py
index edb4c60f8a58553a355245558b30d815000b3e11..d4fea4fbb0223d079149224e2d3d89487834ca40 100644
--- a/tensorflow/python/keras/_impl/keras/applications/inception_v3.py
+++ b/tensorflow/python/keras/_impl/keras/applications/inception_v3.py
@@ -31,6 +31,7 @@ from __future__ import print_function
 
 from tensorflow.python.keras._impl.keras import backend as K
 from tensorflow.python.keras._impl.keras import layers
+from tensorflow.python.keras._impl.keras.applications import imagenet_utils
 from tensorflow.python.keras._impl.keras.applications.imagenet_utils import _obtain_input_shape
 from tensorflow.python.keras._impl.keras.applications.imagenet_utils import decode_predictions  # pylint: disable=unused-import
 from tensorflow.python.keras._impl.keras.engine.topology import get_source_inputs
@@ -374,19 +375,24 @@ def InceptionV3(include_top=True,
           'inception_v3_weights_tf_dim_ordering_tf_kernels.h5',
           WEIGHTS_PATH,
           cache_subdir='models',
-          md5_hash='9a0d58056eeedaa3f26cb7ebd46da564')
+          file_hash='9a0d58056eeedaa3f26cb7ebd46da564')
     else:
       weights_path = get_file(
           'inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5',
           WEIGHTS_PATH_NO_TOP,
           cache_subdir='models',
-          md5_hash='bcbd6486424b2319ff4ef7d526e38f63')
+          file_hash='bcbd6486424b2319ff4ef7d526e38f63')
     model.load_weights(weights_path)
   return model
 
 
 def preprocess_input(x):
-  x /= 255.
-  x -= 0.5
-  x *= 2.
-  return x
+  """Preprocesses a numpy array encoding a batch of images.
+
+  Arguments:
+      x: a 4D numpy array consists of RGB values within [0, 255].
+
+  Returns:
+      Preprocessed array.
+  """
+  return imagenet_utils.preprocess_input(x, mode='tf')
diff --git a/tensorflow/python/keras/_impl/keras/applications/mobilenet.py b/tensorflow/python/keras/_impl/keras/applications/mobilenet.py
index f6482d25496521c3926e39bdd69239a81884ece4..653bd8c09f2d7a4ac2f6cb5e6c792b2285b378cc 100644
--- a/tensorflow/python/keras/_impl/keras/applications/mobilenet.py
+++ b/tensorflow/python/keras/_impl/keras/applications/mobilenet.py
@@ -73,6 +73,7 @@ from tensorflow.python.keras._impl.keras import backend as K
 from tensorflow.python.keras._impl.keras import constraints
 from tensorflow.python.keras._impl.keras import initializers
 from tensorflow.python.keras._impl.keras import regularizers
+from tensorflow.python.keras._impl.keras.applications import imagenet_utils
 from tensorflow.python.keras._impl.keras.applications.imagenet_utils import _obtain_input_shape
 from tensorflow.python.keras._impl.keras.applications.imagenet_utils import decode_predictions  # pylint: disable=unused-import
 from tensorflow.python.keras._impl.keras.engine import InputSpec
@@ -97,10 +98,15 @@ def relu6(x):
 
 
 def preprocess_input(x):
-  x /= 255.
-  x -= 0.5
-  x *= 2.
-  return x
+  """Preprocesses a numpy array encoding a batch of images.
+
+  Arguments:
+      x: a 4D numpy array consists of RGB values within [0, 255].
+
+  Returns:
+      Preprocessed array.
+  """
+  return imagenet_utils.preprocess_input(x, mode='tf')
 
 
 class DepthwiseConv2D(Conv2D):
diff --git a/tensorflow/python/keras/_impl/keras/applications/resnet50.py b/tensorflow/python/keras/_impl/keras/applications/resnet50.py
index f0cff2d686f321e4ec86a85efc8a844576fc7fcf..717b626fdc3c65d510cf190e53b4b1c04a89ebfa 100644
--- a/tensorflow/python/keras/_impl/keras/applications/resnet50.py
+++ b/tensorflow/python/keras/_impl/keras/applications/resnet50.py
@@ -56,7 +56,7 @@ def identity_block(input_tensor, kernel_size, filters, stage, block):
   Arguments:
       input_tensor: input tensor
       kernel_size: default 3, the kernel size of middle conv layer at main path
-      filters: list of integers, the filterss of 3 conv layer at main path
+      filters: list of integers, the filters of 3 conv layer at main path
       stage: integer, current stage label, used for generating layer names
       block: 'a','b'..., current block label, used for generating layer names
 
@@ -95,7 +95,7 @@ def conv_block(input_tensor, kernel_size, filters, stage, block, strides=(2,
   Arguments:
       input_tensor: input tensor
       kernel_size: default 3, the kernel size of middle conv layer at main path
-      filters: list of integers, the filterss of 3 conv layer at main path
+      filters: list of integers, the filters of 3 conv layer at main path
       stage: integer, current stage label, used for generating layer names
       block: 'a','b'..., current block label, used for generating layer names
       strides: Tuple of integers.
diff --git a/tensorflow/python/keras/_impl/keras/applications/vgg16.py b/tensorflow/python/keras/_impl/keras/applications/vgg16.py
index 485b486e9d826795d3499b978d119609050bd7de..a0862e6407747cd0ad3d698c63da77b17c272e1b 100644
--- a/tensorflow/python/keras/_impl/keras/applications/vgg16.py
+++ b/tensorflow/python/keras/_impl/keras/applications/vgg16.py
@@ -192,12 +192,14 @@ def VGG16(include_top=True,
       weights_path = get_file(
           'vgg16_weights_tf_dim_ordering_tf_kernels.h5',
           WEIGHTS_PATH,
-          cache_subdir='models')
+          cache_subdir='models',
+          file_hash='64373286793e3c8b2b4e3219cbf3544b')
     else:
       weights_path = get_file(
           'vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5',
           WEIGHTS_PATH_NO_TOP,
-          cache_subdir='models')
+          cache_subdir='models',
+          file_hash='6d6bbae143d832006294945121d1f1fc')
     model.load_weights(weights_path)
     if K.backend() == 'theano':
       layer_utils.convert_all_kernels_in_model(model)
diff --git a/tensorflow/python/keras/_impl/keras/applications/vgg19.py b/tensorflow/python/keras/_impl/keras/applications/vgg19.py
index 3af6417c8444453a9e9c3eef70097f520757f264..cfa1c95336e8ab798e4d5bd67f9c7f89e4705ca7 100644
--- a/tensorflow/python/keras/_impl/keras/applications/vgg19.py
+++ b/tensorflow/python/keras/_impl/keras/applications/vgg19.py
@@ -198,12 +198,14 @@ def VGG19(include_top=True,
       weights_path = get_file(
           'vgg19_weights_tf_dim_ordering_tf_kernels.h5',
           WEIGHTS_PATH,
-          cache_subdir='models')
+          cache_subdir='models',
+          file_hash='cbe5617147190e668d6c5d5026f83318')
     else:
       weights_path = get_file(
           'vgg19_weights_tf_dim_ordering_tf_kernels_notop.h5',
           WEIGHTS_PATH_NO_TOP,
-          cache_subdir='models')
+          cache_subdir='models',
+          file_hash='253f8cb515780f3b799900260a226db6')
     model.load_weights(weights_path)
     if K.backend() == 'theano':
       layer_utils.convert_all_kernels_in_model(model)
diff --git a/tensorflow/python/keras/_impl/keras/applications/xception.py b/tensorflow/python/keras/_impl/keras/applications/xception.py
index 6e521daa2d3b9eae33faecde6057e9fcc3222edc..14f6ad809015aae451f8ddc13fa64166b06995a6 100644
--- a/tensorflow/python/keras/_impl/keras/applications/xception.py
+++ b/tensorflow/python/keras/_impl/keras/applications/xception.py
@@ -38,6 +38,7 @@ from __future__ import print_function
 
 from tensorflow.python.keras._impl.keras import backend as K
 from tensorflow.python.keras._impl.keras import layers
+from tensorflow.python.keras._impl.keras.applications import imagenet_utils
 from tensorflow.python.keras._impl.keras.applications.imagenet_utils import _obtain_input_shape
 from tensorflow.python.keras._impl.keras.applications.imagenet_utils import decode_predictions  # pylint: disable=unused-import
 from tensorflow.python.keras._impl.keras.engine.topology import get_source_inputs
@@ -287,12 +288,14 @@ def Xception(include_top=True,
       weights_path = get_file(
           'xception_weights_tf_dim_ordering_tf_kernels.h5',
           TF_WEIGHTS_PATH,
-          cache_subdir='models')
+          cache_subdir='models',
+          file_hash='0a58e3b7378bc2990ea3b43d5981f1f6')
     else:
       weights_path = get_file(
           'xception_weights_tf_dim_ordering_tf_kernels_notop.h5',
           TF_WEIGHTS_PATH_NO_TOP,
-          cache_subdir='models')
+          cache_subdir='models',
+          file_hash='b0042744bf5b25fce3cb969f33bebb97')
     model.load_weights(weights_path)
 
   if old_data_format:
@@ -301,7 +304,12 @@ def Xception(include_top=True,
 
 
 def preprocess_input(x):
-  x /= 255.
-  x -= 0.5
-  x *= 2.
-  return x
+  """Preprocesses a numpy array encoding a batch of images.
+
+  Arguments:
+      x: a 4D numpy array consists of RGB values within [0, 255].
+
+  Returns:
+      Preprocessed array.
+  """
+  return imagenet_utils.preprocess_input(x, mode='tf')
diff --git a/tensorflow/python/keras/_impl/keras/backend.py b/tensorflow/python/keras/_impl/keras/backend.py
index f7f582bfe75a807f37c6dc30c126ec9b5ae596ba..f9a53c4eb4dd8a6445c520dbc99d293cb1162254 100644
--- a/tensorflow/python/keras/_impl/keras/backend.py
+++ b/tensorflow/python/keras/_impl/keras/backend.py
@@ -90,6 +90,11 @@ _EPSILON = 10e-8
 # Default image data format, one of "channels_last", "channels_first".
 _IMAGE_DATA_FORMAT = 'channels_last'
 
+# This list holds the available devices.
+# It is populated when `_get_available_gpus()` is called for the first time.
+# We assume our devices don't change henceforth.
+_LOCAL_DEVICES = None
+
 
 def backend():
   """Publicly accessible method for determining the current backend.
@@ -442,8 +447,10 @@ def _get_available_gpus():
   Returns:
       A list of available GPU devices.
   """
-  devices = get_session().list_devices()
-  return [x.name for x in devices if x.device_type == 'GPU']
+  global _LOCAL_DEVICES
+  if _LOCAL_DEVICES is None:
+    _LOCAL_DEVICES = get_session().list_devices()
+  return [x.name for x in _LOCAL_DEVICES if x.device_type == 'GPU']
 
 
 def _has_nchw_support():
diff --git a/tensorflow/python/keras/applications/__init__.py b/tensorflow/python/keras/applications/__init__.py
index e34d9a8e0b9178a234ab6a6fc1090063363fa9b4..34f1435ffb6b65ef0e1399fb6893c3b791616f79 100644
--- a/tensorflow/python/keras/applications/__init__.py
+++ b/tensorflow/python/keras/applications/__init__.py
@@ -18,12 +18,14 @@ from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
+from tensorflow.python.keras.applications import inception_resnet_v2
 from tensorflow.python.keras.applications import inception_v3
 from tensorflow.python.keras.applications import mobilenet
 from tensorflow.python.keras.applications import resnet50
 from tensorflow.python.keras.applications import vgg16
 from tensorflow.python.keras.applications import vgg19
 from tensorflow.python.keras.applications import xception
+from tensorflow.python.keras.applications.inception_resnet_v2 import InceptionResNetV2
 from tensorflow.python.keras.applications.inception_v3 import InceptionV3
 from tensorflow.python.keras.applications.mobilenet import MobileNet
 from tensorflow.python.keras.applications.resnet50 import ResNet50
diff --git a/tensorflow/python/keras/applications/inception_resnet_v2/__init__.py b/tensorflow/python/keras/applications/inception_resnet_v2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..223660e9bef33896bc83f43ed26c1792e48105b9
--- /dev/null
+++ b/tensorflow/python/keras/applications/inception_resnet_v2/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""InceptionResNetV2 Keras application."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from tensorflow.python.keras._impl.keras.applications.inception_resnet_v2 import decode_predictions
+from tensorflow.python.keras._impl.keras.applications.inception_resnet_v2 import InceptionResNetV2
+from tensorflow.python.keras._impl.keras.applications.inception_resnet_v2 import preprocess_input
+
+del absolute_import
+del division
+del print_function
diff --git a/tensorflow/python/kernel_tests/BUILD b/tensorflow/python/kernel_tests/BUILD
index cbb9ac2a74da2d423fa4125f368f07fc4e3e490b..7fa504e85edfe8e5ea63c6782d2bf72a88e4eae8 100644
--- a/tensorflow/python/kernel_tests/BUILD
+++ b/tensorflow/python/kernel_tests/BUILD
@@ -505,6 +505,18 @@ tf_py_test(
     ],
 )
 
+tf_py_test(
+    name = "matrix_exponential_op_test",
+    size = "small",
+    srcs = ["matrix_exponential_op_test.py"],
+    additional_deps = [
+        "//third_party/py/numpy",
+        "//tensorflow/python:client_testlib",
+        "//tensorflow/python:framework_for_generated_wrappers",
+        "//tensorflow/python:linalg_ops",
+    ],
+)
+
 cuda_py_test(
     name = "matrix_inverse_op_test",
     size = "small",
@@ -2859,6 +2871,20 @@ tf_py_test(
     ],
 )
 
+tf_py_test(
+    name = "garbage_collection_test",
+    size = "small",
+    srcs = ["garbage_collection_test.py"],
+    additional_deps = [
+        "//tensorflow/python/eager:context",
+        "//tensorflow/python:framework_test_lib",
+        "//tensorflow/python:resource_variable_ops",
+        "//tensorflow/python:dtypes",
+        "//tensorflow/python:tensor_array_ops",
+        "//tensorflow/python:client_testlib",
+    ],
+)
+
 tf_py_test(
     name = "list_files_dataset_op_test",
     size = "small",
diff --git a/tensorflow/python/kernel_tests/checkpoint_ops_test.py b/tensorflow/python/kernel_tests/checkpoint_ops_test.py
index d2eb3eb80170de26c6fa00fdace1254a51a2b0ec..a786d0a47e569f71812086fb93c21dc12660a2a5 100644
--- a/tensorflow/python/kernel_tests/checkpoint_ops_test.py
+++ b/tensorflow/python/kernel_tests/checkpoint_ops_test.py
@@ -87,6 +87,21 @@ class GenerateVocabRemappingTest(test.TestCase):
       self.assertAllEqual(expected_remapping, remapping.eval())
       self.assertAllEqual(expected_num_present, num_present.eval())
 
+  def test_generate_remapping_with_old_vocab_size(self):
+    """Tests where old_vocab_size is specified."""
+    remapping, num_present = gen_checkpoint_ops._generate_vocab_remapping(
+        new_vocab_file=self.new_vocab_file,
+        old_vocab_file=self.old_vocab_file,
+        num_new_vocab=3,
+        new_vocab_offset=0,
+        # Old vocabulary becomes ['knitting', 'eminem'].
+        old_vocab_size=2)
+    expected_remapping = [-1, 0, 1]
+    expected_num_present = 2
+    with self.test_session():
+      self.assertAllEqual(expected_remapping, remapping.eval())
+      self.assertAllEqual(expected_num_present, num_present.eval())
+
 
 class LoadAndRemapMatrixTest(test.TestCase):
   """Tests for the load_and_remap_matrix() op."""
diff --git a/tensorflow/python/kernel_tests/depthtospace_op_test.py b/tensorflow/python/kernel_tests/depthtospace_op_test.py
index 792806642a4f495942700cf052deba04fff1ed74..7df2366954f3a6f3f37aef447479ba67c263025f 100644
--- a/tensorflow/python/kernel_tests/depthtospace_op_test.py
+++ b/tensorflow/python/kernel_tests/depthtospace_op_test.py
@@ -284,11 +284,16 @@ class DepthToSpaceTest(test.TestCase):
 class DepthToSpaceGradientTest(test.TestCase):
 
   # Check the gradients.
-  def _checkGrad(self, x, block_size):
+  def _checkGrad(self, x, block_size, data_format):
+    # NCHW is implemented for only GPU.
+    if data_format == "NCHW" and not test.is_gpu_available():
+      return
+
     assert 4 == x.ndim
     with self.test_session(use_gpu=True):
       tf_x = ops.convert_to_tensor(x)
-      tf_y = array_ops.depth_to_space(tf_x, block_size)
+      tf_y = array_ops.depth_to_space(tf_x, block_size, data_format=data_format)
+
       epsilon = 1e-2
       ((x_jacob_t, x_jacob_n)) = gradient_checker.compute_gradient(
           tf_x,
@@ -297,28 +302,32 @@ class DepthToSpaceGradientTest(test.TestCase):
           tf_y.get_shape().as_list(),
           x_init_value=x,
           delta=epsilon)
-
-    self.assertAllClose(x_jacob_t, x_jacob_n, rtol=1e-2, atol=epsilon)
+      self.assertAllClose(x_jacob_t, x_jacob_n, rtol=1e-2, atol=epsilon)
 
   # Tests a gradient for depth_to_space of x which is a four dimensional
   # tensor of shape [b, h, w, d * block_size * block_size].
-  def _compare(self, b, h, w, d, block_size):
+  def _compare(self, b, h, w, d, block_size, data_format):
     block_size_sq = block_size * block_size
-    x = np.random.normal(
-        0, 1, b * h * w * d * block_size_sq).astype(np.float32).reshape(
-            [b, h, w, d * block_size_sq])
+    data = np.random.normal(0, 1, b * h * w * d * block_size_sq).astype(
+        np.float32)
+    if data_format == "NHWC":
+      x = data.reshape([b, h, w, d * block_size_sq])
+    else:
+      x = data.reshape([b, d * block_size_sq, h, w])
 
-    self._checkGrad(x, block_size)
+    self._checkGrad(x, block_size, data_format)
 
   # Don't use very large numbers as dimensions here, as the result is tensor
   # with cartesian product of the dimensions.
   def testSmall(self):
     block_size = 2
-    self._compare(3, 2, 5, 3, block_size)
+    self._compare(3, 2, 5, 3, block_size, "NHWC")
+    self._compare(3, 2, 5, 3, block_size, "NCHW")
 
   def testSmall2(self):
     block_size = 3
-    self._compare(1, 2, 3, 2, block_size)
+    self._compare(1, 2, 3, 2, block_size, "NHWC")
+    self._compare(1, 2, 3, 2, block_size, "NCHW")
 
 
 if __name__ == "__main__":
diff --git a/tensorflow/python/kernel_tests/distributions/special_math_test.py b/tensorflow/python/kernel_tests/distributions/special_math_test.py
index dc462bae56b5fbc18036e80f6bbd4177b7b9fff2..9441cdbe39ed2fe83a34b4c3d6f9f2e92006365d 100644
--- a/tensorflow/python/kernel_tests/distributions/special_math_test.py
+++ b/tensorflow/python/kernel_tests/distributions/special_math_test.py
@@ -24,6 +24,7 @@ import importlib
 import numpy as np
 
 from tensorflow.python.framework import ops
+from tensorflow.python.ops import array_ops
 from tensorflow.python.ops import gradient_checker
 from tensorflow.python.ops import gradients_impl
 from tensorflow.python.ops import variables
@@ -90,6 +91,21 @@ class NdtriTest(test.TestCase):
       x = special_math.ndtri(p)
       self.assertAllClose(expected_x, x.eval(), atol=0.)
 
+  def testNdtriDynamicShape(self):
+    """Verifies that ndtri computation is correct."""
+    with self.test_session() as sess:
+      if not special:
+        return
+
+      p = array_ops.placeholder(np.float32)
+      p_ = np.linspace(0., 1.0, 50).astype(np.float32)
+
+      x = special_math.ndtri(p)
+      x_ = sess.run(x, feed_dict={p: p_})
+
+      expected_x_ = special.ndtri(p_)
+      self.assertAllClose(expected_x_, x_, atol=0.)
+
   def _baseNdtriFiniteGradientTest(self, dtype):
     """Verifies that ndtri has finite gradients at interesting points."""
     g = ops.Graph()
diff --git a/tensorflow/python/kernel_tests/garbage_collection_test.py b/tensorflow/python/kernel_tests/garbage_collection_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..39f936fbc92af597f967024cce9bca82ede15440
--- /dev/null
+++ b/tensorflow/python/kernel_tests/garbage_collection_test.py
@@ -0,0 +1,63 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests which set DEBUG_SAVEALL and assert no garbage was created.
+
+This flag seems to be sticky, so these tests have been isolated for now.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from tensorflow.python.eager import context
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import test_util
+from tensorflow.python.ops import resource_variable_ops
+from tensorflow.python.ops import tensor_array_ops
+from tensorflow.python.platform import test
+
+
+class NoReferenceCycleTests(test_util.TensorFlowTestCase):
+
+  @test_util.assert_no_garbage_created
+  def testEagerResourceVariables(self):
+    with context.eager_mode():
+      resource_variable_ops.ResourceVariable(1.0, name="a")
+
+  @test_util.assert_no_garbage_created
+  def testTensorArrays(self):
+    with context.eager_mode():
+      ta = tensor_array_ops.TensorArray(
+          dtype=dtypes.float32,
+          tensor_array_name="foo",
+          size=3,
+          infer_shape=False)
+
+      w0 = ta.write(0, [[4.0, 5.0]])
+      w1 = w0.write(1, [[1.0]])
+      w2 = w1.write(2, -3.0)
+
+      r0 = w2.read(0)
+      r1 = w2.read(1)
+      r2 = w2.read(2)
+
+      d0, d1, d2 = self.evaluate([r0, r1, r2])
+      self.assertAllEqual([[4.0, 5.0]], d0)
+      self.assertAllEqual([[1.0]], d1)
+      self.assertAllEqual(-3.0, d2)
+
+
+if __name__ == "__main__":
+  test.main()
diff --git a/tensorflow/python/kernel_tests/iterator_ops_test.py b/tensorflow/python/kernel_tests/iterator_ops_test.py
index 2128ef4ae17668309af96c4fb21837cb7659a122..60a44b5b14a70a4bf7b606f84185dd0731b59556 100644
--- a/tensorflow/python/kernel_tests/iterator_ops_test.py
+++ b/tensorflow/python/kernel_tests/iterator_ops_test.py
@@ -17,14 +17,12 @@ from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
-import os
 import numpy as np
 
 from tensorflow.core.protobuf import config_pb2
 from tensorflow.python.client import session
 from tensorflow.python.data.ops import dataset_ops
 from tensorflow.python.data.ops import iterator_ops
-from tensorflow.python.data.ops import readers
 from tensorflow.python.framework import constant_op
 from tensorflow.python.framework import dtypes
 from tensorflow.python.framework import errors
@@ -33,9 +31,7 @@ from tensorflow.python.framework import ops
 from tensorflow.python.framework import test_util
 from tensorflow.python.ops import array_ops
 from tensorflow.python.ops import functional_ops
-from tensorflow.python.ops import gen_dataset_ops
 from tensorflow.python.ops import gradients_impl
-from tensorflow.python.ops import io_ops
 from tensorflow.python.ops import math_ops
 from tensorflow.python.ops import parsing_ops
 from tensorflow.python.ops import script_ops
@@ -537,64 +533,6 @@ class IteratorTest(test.TestCase):
                 target_placeholder: "/job:localhost/replica:0/task:0/cpu:0"
             })
 
-  def testIncorrectIteratorRestore(self):
-
-    def _path():
-      return os.path.join(self.get_temp_dir(), "iterator")
-
-    def _save_op(iterator_resource):
-      iterator_state_variant = gen_dataset_ops.serialize_iterator(
-          iterator_resource)
-      save_op = io_ops.write_file(
-          _path(), parsing_ops.serialize_tensor(iterator_state_variant))
-      return save_op
-
-    def _restore_op(iterator_resource):
-      iterator_state_variant = parsing_ops.parse_tensor(
-          io_ops.read_file(_path()), dtypes.variant)
-      restore_op = gen_dataset_ops.deserialize_iterator(iterator_resource,
-                                                        iterator_state_variant)
-      return restore_op
-
-    def _build_range_dataset_graph():
-      start = 1
-      stop = 10
-      iterator = dataset_ops.Dataset.range(start,
-                                           stop).make_initializable_iterator()
-      init_op = iterator.initializer
-      get_next = iterator.get_next()
-      save_op = _save_op(iterator._iterator_resource)
-      restore_op = _restore_op(iterator._iterator_resource)
-      return init_op, get_next, save_op, restore_op
-
-    def _build_reader_dataset_graph():
-      filenames = ["test"]  # Does not exist but we don't care in this test.
-      iterator = readers.FixedLengthRecordDataset(
-          filenames, 1, 0, 0).make_initializable_iterator()
-      init_op = iterator.initializer
-      get_next_op = iterator.get_next()
-      save_op = _save_op(iterator._iterator_resource)
-      restore_op = _restore_op(iterator._iterator_resource)
-      return init_op, get_next_op, save_op, restore_op
-
-    # Saving iterator for RangeDataset graph.
-    with ops.Graph().as_default() as g:
-      init_op, _, save_op, _ = _build_range_dataset_graph()
-      with self.test_session(graph=g) as sess:
-        sess.run(init_op)
-        sess.run(save_op)
-
-    # Attempt to restore the saved iterator into an IteratorResource of
-    # incompatible type. An iterator of RangeDataset has output type int64,
-    # while an iterator of FixedLengthRecordDataset has output type string.
-    # So an InvalidArgumentError should be raised by
-    # IteratorResource::set_iterator.
-    with ops.Graph().as_default() as g:
-      _, _, _, restore_op = _build_reader_dataset_graph()
-      with self.test_session(graph=g) as sess:
-        with self.assertRaises(errors.InvalidArgumentError):
-          sess.run(restore_op)
-
 
 if __name__ == "__main__":
   test.main()
diff --git a/tensorflow/python/kernel_tests/matrix_exponential_op_test.py b/tensorflow/python/kernel_tests/matrix_exponential_op_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5a7a3ba99ba161c197643a3e3c5aed5d37e9d2b
--- /dev/null
+++ b/tensorflow/python/kernel_tests/matrix_exponential_op_test.py
@@ -0,0 +1,196 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for tensorflow.ops.gen_linalg_ops.matrix_exponential."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import itertools
+import math
+
+import numpy as np
+
+from tensorflow.python.client import session
+from tensorflow.python.framework import constant_op
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import control_flow_ops
+from tensorflow.python.ops import gen_linalg_ops
+from tensorflow.python.ops import random_ops
+from tensorflow.python.ops import variables
+from tensorflow.python.platform import test
+
+
+def np_expm(x):
+  """Slow but accurate Taylor series matrix exponential."""
+  y = np.zeros(x.shape, dtype=x.dtype)
+  xn = np.eye(x.shape[0], dtype=x.dtype)
+  for n in range(40):
+    y += xn / float(math.factorial(n))
+    xn = np.dot(xn, x)
+  return y
+
+
+class ExponentialOpTest(test.TestCase):
+
+  def _verifyExponential(self, x, np_type):
+    # TODO(pfau): add matrix logarithm and test that it is inverse of expm.
+    inp = x.astype(np_type)
+    with self.test_session(use_gpu=True):
+      # Verify that x^{-1} * x == Identity matrix.
+      tf_ans = gen_linalg_ops._matrix_exponential(inp)
+      if x.size == 0:
+        np_ans = np.empty(x.shape, dtype=np_type)
+      else:
+        if x.ndim > 2:
+          np_ans = np.zeros(inp.shape, dtype=np_type)
+          for i in itertools.product(*[range(x) for x in inp.shape[:-2]]):
+            np_ans[i] = np_expm(inp[i])
+        else:
+          np_ans = np_expm(inp)
+      out = tf_ans.eval()
+      self.assertAllClose(np_ans, out, rtol=1e-4, atol=1e-3)
+
+  def _verifyExponentialReal(self, x):
+    for np_type in [np.float32, np.float64]:
+      self._verifyExponential(x, np_type)
+
+  def _verifyExponentialComplex(self, x):
+    for np_type in [np.complex64, np.complex128]:
+      self._verifyExponential(x, np_type)
+
+  def _makeBatch(self, matrix1, matrix2):
+    matrix_batch = np.concatenate(
+        [np.expand_dims(matrix1, 0),
+         np.expand_dims(matrix2, 0)])
+    matrix_batch = np.tile(matrix_batch, [2, 3, 1, 1])
+    return matrix_batch
+
+  def testNonsymmetric(self):
+    # 2x2 matrices
+    matrix1 = np.array([[1., 2.], [3., 4.]])
+    matrix2 = np.array([[1., 3.], [3., 5.]])
+    self._verifyExponentialReal(matrix1)
+    self._verifyExponentialReal(matrix2)
+    # A multidimensional batch of 2x2 matrices
+    self._verifyExponentialReal(self._makeBatch(matrix1, matrix2))
+    # Complex
+    matrix1 = matrix1.astype(np.complex64)
+    matrix1 += 1j * matrix1
+    matrix2 = matrix2.astype(np.complex64)
+    matrix2 += 1j * matrix2
+    self._verifyExponentialComplex(matrix1)
+    self._verifyExponentialComplex(matrix2)
+    # Complex batch
+    self._verifyExponentialComplex(self._makeBatch(matrix1, matrix2))
+
+  def testSymmetricPositiveDefinite(self):
+    # 2x2 matrices
+    matrix1 = np.array([[2., 1.], [1., 2.]])
+    matrix2 = np.array([[3., -1.], [-1., 3.]])
+    self._verifyExponentialReal(matrix1)
+    self._verifyExponentialReal(matrix2)
+    # A multidimensional batch of 2x2 matrices
+    self._verifyExponentialReal(self._makeBatch(matrix1, matrix2))
+    # Complex
+    matrix1 = matrix1.astype(np.complex64)
+    matrix1 += 1j * matrix1
+    matrix2 = matrix2.astype(np.complex64)
+    matrix2 += 1j * matrix2
+    self._verifyExponentialComplex(matrix1)
+    self._verifyExponentialComplex(matrix2)
+    # Complex batch
+    self._verifyExponentialComplex(self._makeBatch(matrix1, matrix2))
+
+  def testNonSquareMatrix(self):
+    # When the exponential of a non-square matrix is attempted we should return
+    # an error
+    with self.assertRaises(ValueError):
+      gen_linalg_ops._matrix_exponential(np.array([[1., 2., 3.], [3., 4., 5.]]))
+
+  def testWrongDimensions(self):
+    # The input to the inverse should be at least a 2-dimensional tensor.
+    tensor3 = constant_op.constant([1., 2.])
+    with self.assertRaises(ValueError):
+      gen_linalg_ops._matrix_exponential(tensor3)
+
+  def testEmpty(self):
+    self._verifyExponentialReal(np.empty([0, 2, 2]))
+    self._verifyExponentialReal(np.empty([2, 0, 0]))
+
+  def testRandomSmallAndLarge(self):
+    np.random.seed(42)
+    for dtype in np.float32, np.float64, np.complex64, np.complex128:
+      for batch_dims in [(), (1,), (3,), (2, 2)]:
+        for size in 8, 31, 32:
+          shape = batch_dims + (size, size)
+          matrix = np.random.uniform(
+              low=-1.0, high=1.0,
+              size=np.prod(shape)).reshape(shape).astype(dtype)
+          self._verifyExponentialReal(matrix)
+
+  def testConcurrentExecutesWithoutError(self):
+    with self.test_session(use_gpu=True) as sess:
+      matrix1 = random_ops.random_normal([5, 5], seed=42)
+      matrix2 = random_ops.random_normal([5, 5], seed=42)
+      expm1 = gen_linalg_ops._matrix_exponential(matrix1)
+      expm2 = gen_linalg_ops._matrix_exponential(matrix2)
+      expm = sess.run([expm1, expm2])
+      self.assertAllEqual(expm[0], expm[1])
+
+
+class MatrixExponentialBenchmark(test.Benchmark):
+
+  shapes = [
+      (4, 4),
+      (10, 10),
+      (16, 16),
+      (101, 101),
+      (256, 256),
+      (1000, 1000),
+      (1024, 1024),
+      (2048, 2048),
+      (513, 4, 4),
+      (513, 16, 16),
+      (513, 256, 256),
+  ]
+
+  def _GenerateMatrix(self, shape):
+    batch_shape = shape[:-2]
+    shape = shape[-2:]
+    assert shape[0] == shape[1]
+    n = shape[0]
+    matrix = np.ones(shape).astype(np.float32) / (
+        2.0 * n) + np.diag(np.ones(n).astype(np.float32))
+    return variables.Variable(np.tile(matrix, batch_shape + (1, 1)))
+
+  def benchmarkMatrixExponentialOp(self):
+    for shape in self.shapes:
+      with ops.Graph().as_default(), \
+          session.Session() as sess, \
+          ops.device("/cpu:0"):
+        matrix = self._GenerateMatrix(shape)
+        expm = gen_linalg_ops._matrix_exponential(matrix)
+        variables.global_variables_initializer().run()
+        self.run_op_benchmark(
+            sess,
+            control_flow_ops.group(expm),
+            min_iters=25,
+            name="matrix_exponential_cpu_{shape}".format(
+                shape=shape))
+
+
+if __name__ == "__main__":
+  test.main()
diff --git a/tensorflow/python/kernel_tests/metrics_test.py b/tensorflow/python/kernel_tests/metrics_test.py
index 7cc86b5a5c741a52349205a7c2577443a0ec6c26..971dc9d55302090bbe71174903de5b9dda37d1bc 100644
--- a/tensorflow/python/kernel_tests/metrics_test.py
+++ b/tensorflow/python/kernel_tests/metrics_test.py
@@ -1801,17 +1801,17 @@ class PrecisionRecallThresholdsTest(test.TestCase):
       self.assertAlmostEqual(expected_rec, rec.eval(), 2)
 
 
-def _test_sparse_precision_at_k(predictions,
-                                labels,
-                                k,
-                                expected,
-                                class_id=None,
-                                weights=None,
-                                test_case=None):
+def _test_precision_at_k(predictions,
+                         labels,
+                         k,
+                         expected,
+                         class_id=None,
+                         weights=None,
+                         test_case=None):
   with ops.Graph().as_default() as g, test_case.test_session(g):
     if weights is not None:
       weights = constant_op.constant(weights, dtypes_lib.float32)
-    metric, update = metrics.sparse_precision_at_k(
+    metric, update = metrics.precision_at_k(
         predictions=constant_op.constant(predictions, dtypes_lib.float32),
         labels=labels,
         k=k,
@@ -1864,17 +1864,17 @@ def _test_precision_at_top_k(
       test_case.assertEqual(expected, metric.eval())
 
 
-def _test_sparse_average_precision_at_k(predictions,
-                                        labels,
-                                        k,
-                                        expected,
-                                        weights=None,
-                                        test_case=None):
+def _test_average_precision_at_k(predictions,
+                                 labels,
+                                 k,
+                                 expected,
+                                 weights=None,
+                                 test_case=None):
   with ops.Graph().as_default() as g, test_case.test_session(g):
     if weights is not None:
       weights = constant_op.constant(weights, dtypes_lib.float32)
     predictions = constant_op.constant(predictions, dtypes_lib.float32)
-    metric, update = metrics.sparse_average_precision_at_k(
+    metric, update = metrics.average_precision_at_k(
         labels, predictions, k, weights=weights)
 
     # Fails without initialized vars.
@@ -1891,7 +1891,7 @@ def _test_sparse_average_precision_at_k(predictions,
       test_case.assertAlmostEqual(expected, metric.eval())
 
 
-class SingleLabelSparsePrecisionTest(test.TestCase):
+class SingleLabelPrecisionAtKTest(test.TestCase):
 
   def setUp(self):
     self._predictions = ((0.1, 0.3, 0.2, 0.4), (0.1, 0.2, 0.3, 0.4))
@@ -1904,18 +1904,18 @@ class SingleLabelSparsePrecisionTest(test.TestCase):
         _binary_2d_label_to_2d_sparse_value(indicator_labels), np.array(
             class_labels, dtype=np.int64), np.array(
                 [[class_id] for class_id in class_labels], dtype=np.int64))
-    self._test_sparse_precision_at_k = functools.partial(
-        _test_sparse_precision_at_k, test_case=self)
+    self._test_precision_at_k = functools.partial(
+        _test_precision_at_k, test_case=self)
     self._test_precision_at_top_k = functools.partial(
         _test_precision_at_top_k, test_case=self)
-    self._test_sparse_average_precision_at_k = functools.partial(
-        _test_sparse_average_precision_at_k, test_case=self)
+    self._test_average_precision_at_k = functools.partial(
+        _test_average_precision_at_k, test_case=self)
 
   def test_at_k1_nan(self):
     for labels in self._labels:
       # Classes 0,1,2 have 0 predictions, classes -1 and 4 are out of range.
       for class_id in (-1, 0, 1, 2, 4):
-        self._test_sparse_precision_at_k(
+        self._test_precision_at_k(
             self._predictions, labels, k=1, expected=NAN, class_id=class_id)
         self._test_precision_at_top_k(
             self._predictions_idx, labels, k=1, expected=NAN, class_id=class_id)
@@ -1923,29 +1923,29 @@ class SingleLabelSparsePrecisionTest(test.TestCase):
   def test_at_k1(self):
     for labels in self._labels:
       # Class 3: 1 label, 2 predictions, 1 correct.
-      self._test_sparse_precision_at_k(
+      self._test_precision_at_k(
           self._predictions, labels, k=1, expected=1.0 / 2, class_id=3)
       self._test_precision_at_top_k(
           self._predictions_idx, labels, k=1, expected=1.0 / 2, class_id=3)
 
       # All classes: 2 labels, 2 predictions, 1 correct.
-      self._test_sparse_precision_at_k(
+      self._test_precision_at_k(
           self._predictions, labels, k=1, expected=1.0 / 2)
       self._test_precision_at_top_k(
           self._predictions_idx, labels, k=1, expected=1.0 / 2)
-      self._test_sparse_average_precision_at_k(
+      self._test_average_precision_at_k(
           self._predictions, labels, k=1, expected=1.0 / 2)
 
 
-class MultiLabelSparsePrecisionTest(test.TestCase):
+class MultiLabelPrecisionAtKTest(test.TestCase):
 
   def setUp(self):
-    self._test_sparse_precision_at_k = functools.partial(
-        _test_sparse_precision_at_k, test_case=self)
+    self._test_precision_at_k = functools.partial(
+        _test_precision_at_k, test_case=self)
     self._test_precision_at_top_k = functools.partial(
         _test_precision_at_top_k, test_case=self)
-    self._test_sparse_average_precision_at_k = functools.partial(
-        _test_sparse_average_precision_at_k, test_case=self)
+    self._test_average_precision_at_k = functools.partial(
+        _test_average_precision_at_k, test_case=self)
 
   def test_average_precision(self):
     # Example 1.
@@ -1961,11 +1961,11 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
                          (precision_ex1[1] + precision_ex1[3]) / 4)
     for i in xrange(4):
       k = i + 1
-      self._test_sparse_precision_at_k(
+      self._test_precision_at_k(
           predictions, labels, k, expected=precision_ex1[i])
       self._test_precision_at_top_k(
           (predictions_idx_ex1[:k],), labels, k=k, expected=precision_ex1[i])
-      self._test_sparse_average_precision_at_k(
+      self._test_average_precision_at_k(
           predictions, labels, k, expected=avg_precision_ex1[i])
 
     # Example 2.
@@ -1979,11 +1979,11 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
                          (precision_ex2[2] + precision_ex2[3]) / 4)
     for i in xrange(4):
       k = i + 1
-      self._test_sparse_precision_at_k(
+      self._test_precision_at_k(
           predictions, labels, k, expected=precision_ex2[i])
       self._test_precision_at_top_k(
           (predictions_idx_ex2[:k],), labels, k=k, expected=precision_ex2[i])
-      self._test_sparse_average_precision_at_k(
+      self._test_average_precision_at_k(
           predictions, labels, k, expected=avg_precision_ex2[i])
 
     # Both examples, we expect both precision and average precision to be the
@@ -1999,11 +1999,11 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
     for i in xrange(4):
       k = i + 1
       predictions_idx = (predictions_idx_ex1[:k], predictions_idx_ex2[:k])
-      self._test_sparse_precision_at_k(
+      self._test_precision_at_k(
           predictions, labels, k, expected=streaming_precision[i])
       self._test_precision_at_top_k(
           predictions_idx, labels, k=k, expected=streaming_precision[i])
-      self._test_sparse_average_precision_at_k(
+      self._test_average_precision_at_k(
           predictions, labels, k, expected=streaming_average_precision[i])
 
     # Weighted examples, we expect streaming average precision to be the
@@ -2015,7 +2015,7 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
     ]
     for i in xrange(4):
       k = i + 1
-      self._test_sparse_average_precision_at_k(
+      self._test_average_precision_at_k(
           predictions,
           labels,
           k,
@@ -2034,11 +2034,11 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
                          (precision_ex1[1] + precision_ex1[3]) / 4)
     for i in xrange(4):
       k = i + 1
-      self._test_sparse_precision_at_k(
+      self._test_precision_at_k(
           predictions, labels, k, expected=precision_ex1[i])
       self._test_precision_at_top_k(
           (predictions_idx_ex1[:k],), labels, k=k, expected=precision_ex1[i])
-      self._test_sparse_average_precision_at_k(
+      self._test_average_precision_at_k(
           predictions, labels, k, expected=avg_precision_ex1[i])
 
   def test_three_labels_at_k5_no_predictions(self):
@@ -2052,7 +2052,7 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
     for labels in (sparse_labels, dense_labels):
       # Classes 1,3,8 have 0 predictions, classes -1 and 10 are out of range.
       for class_id in (-1, 1, 3, 8, 10):
-        self._test_sparse_precision_at_k(
+        self._test_precision_at_k(
             predictions, labels, k=5, expected=NAN, class_id=class_id)
         self._test_precision_at_top_k(
             predictions_idx, labels, k=5, expected=NAN, class_id=class_id)
@@ -2068,7 +2068,7 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
     for labels in (sparse_labels, dense_labels):
       # Classes 0,4,6,9: 0 labels, >=1 prediction.
       for class_id in (0, 4, 6, 9):
-        self._test_sparse_precision_at_k(
+        self._test_precision_at_k(
             predictions, labels, k=5, expected=0.0, class_id=class_id)
         self._test_precision_at_top_k(
             predictions_idx, labels, k=5, expected=0.0, class_id=class_id)
@@ -2083,25 +2083,25 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
 
     for labels in (sparse_labels, dense_labels):
       # Class 2: 2 labels, 2 correct predictions.
-      self._test_sparse_precision_at_k(
+      self._test_precision_at_k(
           predictions, labels, k=5, expected=2.0 / 2, class_id=2)
       self._test_precision_at_top_k(
           predictions_idx, labels, k=5, expected=2.0 / 2, class_id=2)
 
       # Class 5: 1 label, 1 correct prediction.
-      self._test_sparse_precision_at_k(
+      self._test_precision_at_k(
           predictions, labels, k=5, expected=1.0 / 1, class_id=5)
       self._test_precision_at_top_k(
           predictions_idx, labels, k=5, expected=1.0 / 1, class_id=5)
 
       # Class 7: 1 label, 1 incorrect prediction.
-      self._test_sparse_precision_at_k(
+      self._test_precision_at_k(
           predictions, labels, k=5, expected=0.0 / 1, class_id=7)
       self._test_precision_at_top_k(
           predictions_idx, labels, k=5, expected=0.0 / 1, class_id=7)
 
       # All classes: 10 predictions, 3 correct.
-      self._test_sparse_precision_at_k(
+      self._test_precision_at_k(
           predictions, labels, k=5, expected=3.0 / 10)
       self._test_precision_at_top_k(
           predictions_idx, labels, k=5, expected=3.0 / 10)
@@ -2119,25 +2119,25 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
         dense_shape=[2, 4])
 
     # Class 2: 2 labels, 2 correct predictions.
-    self._test_sparse_precision_at_k(
+    self._test_precision_at_k(
         predictions, sp_labels, k=5, expected=2.0 / 2, class_id=2)
     self._test_precision_at_top_k(
         predictions_idx, sp_labels, k=5, expected=2.0 / 2, class_id=2)
 
     # Class 5: 1 label, 1 correct prediction.
-    self._test_sparse_precision_at_k(
+    self._test_precision_at_k(
         predictions, sp_labels, k=5, expected=1.0 / 1, class_id=5)
     self._test_precision_at_top_k(
         predictions_idx, sp_labels, k=5, expected=1.0 / 1, class_id=5)
 
     # Class 7: 1 label, 1 incorrect prediction.
-    self._test_sparse_precision_at_k(
+    self._test_precision_at_k(
         predictions, sp_labels, k=5, expected=0.0 / 1, class_id=7)
     self._test_precision_at_top_k(
         predictions_idx, sp_labels, k=5, expected=0.0 / 1, class_id=7)
 
     # All classes: 10 predictions, 3 correct.
-    self._test_sparse_precision_at_k(
+    self._test_precision_at_k(
         predictions, sp_labels, k=5, expected=3.0 / 10)
     self._test_precision_at_top_k(
         predictions_idx, sp_labels, k=5, expected=3.0 / 10)
@@ -2155,7 +2155,7 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
 
     # Classes 1,3,8 have 0 predictions, classes -1 and 10 are out of range.
     for class_id in (-1, 1, 3, 8, 10):
-      self._test_sparse_precision_at_k(
+      self._test_precision_at_k(
           predictions, labels, k=5, expected=NAN, class_id=class_id)
       self._test_precision_at_top_k(
           predictions_idx, labels, k=5, expected=NAN, class_id=class_id)
@@ -2173,7 +2173,7 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
 
     # Classes 0,4,6,9: 0 labels, >=1 prediction.
     for class_id in (0, 4, 6, 9):
-      self._test_sparse_precision_at_k(
+      self._test_precision_at_k(
           predictions, labels, k=5, expected=0.0, class_id=class_id)
       self._test_precision_at_top_k(
           predictions_idx, labels, k=5, expected=0.0, class_id=class_id)
@@ -2190,25 +2190,25 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
          [[0, 1, 1, 0, 0, 1, 0, 1, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 1, 0]]])
 
     # Class 2: 4 predictions, all correct.
-    self._test_sparse_precision_at_k(
+    self._test_precision_at_k(
         predictions, labels, k=5, expected=4.0 / 4, class_id=2)
     self._test_precision_at_top_k(
         predictions_idx, labels, k=5, expected=4.0 / 4, class_id=2)
 
     # Class 5: 2 predictions, both correct.
-    self._test_sparse_precision_at_k(
+    self._test_precision_at_k(
         predictions, labels, k=5, expected=2.0 / 2, class_id=5)
     self._test_precision_at_top_k(
         predictions_idx, labels, k=5, expected=2.0 / 2, class_id=5)
 
     # Class 7: 2 predictions, 1 correct.
-    self._test_sparse_precision_at_k(
+    self._test_precision_at_k(
         predictions, labels, k=5, expected=1.0 / 2, class_id=7)
     self._test_precision_at_top_k(
         predictions_idx, labels, k=5, expected=1.0 / 2, class_id=7)
 
     # All classes: 20 predictions, 7 correct.
-    self._test_sparse_precision_at_k(
+    self._test_precision_at_k(
         predictions, labels, k=5, expected=7.0 / 20)
     self._test_precision_at_top_k(
         predictions_idx, labels, k=5, expected=7.0 / 20)
@@ -2225,7 +2225,7 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
          [[0, 1, 1, 0, 0, 1, 0, 1, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 1, 0]]])
 
     # Class 2: 2 predictions, both correct.
-    self._test_sparse_precision_at_k(
+    self._test_precision_at_k(
         predictions, labels, k=5, expected=2.0 / 2.0, class_id=2,
         weights=[[1], [0]])
     self._test_precision_at_top_k(
@@ -2233,7 +2233,7 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
         weights=[[1], [0]])
 
     # Class 2: 2 predictions, both correct.
-    self._test_sparse_precision_at_k(
+    self._test_precision_at_k(
         predictions, labels, k=5, expected=2.0 / 2.0, class_id=2,
         weights=[[0], [1]])
     self._test_precision_at_top_k(
@@ -2241,7 +2241,7 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
         weights=[[0], [1]])
 
     # Class 7: 1 incorrect prediction.
-    self._test_sparse_precision_at_k(
+    self._test_precision_at_k(
         predictions, labels, k=5, expected=0.0 / 1.0, class_id=7,
         weights=[[1], [0]])
     self._test_precision_at_top_k(
@@ -2249,7 +2249,7 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
         weights=[[1], [0]])
 
     # Class 7: 1 correct prediction.
-    self._test_sparse_precision_at_k(
+    self._test_precision_at_k(
         predictions, labels, k=5, expected=1.0 / 1.0, class_id=7,
         weights=[[0], [1]])
     self._test_precision_at_top_k(
@@ -2257,7 +2257,7 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
         weights=[[0], [1]])
 
     # Class 7: no predictions.
-    self._test_sparse_precision_at_k(
+    self._test_precision_at_k(
         predictions, labels, k=5, expected=NAN, class_id=7,
         weights=[[1, 0], [0, 1]])
     self._test_precision_at_top_k(
@@ -2265,7 +2265,7 @@ class MultiLabelSparsePrecisionTest(test.TestCase):
         weights=[[1, 0], [0, 1]])
 
     # Class 7: 2 predictions, 1 correct.
-    self._test_sparse_precision_at_k(
+    self._test_precision_at_k(
         predictions, labels, k=5, expected=1.0 / 2.0, class_id=7,
         weights=[[0, 1], [1, 0]])
     self._test_precision_at_top_k(
@@ -3569,23 +3569,23 @@ class MeanIOUTest(test.TestCase):
 
   def testMissingClassInLabels(self):
     labels = constant_op.constant([
-      [[0, 0, 1, 1, 0, 0],
-       [1, 0, 0, 0, 0, 1]],
-      [[1, 1, 1, 1, 1, 1],
-       [0, 0, 0, 0, 0, 0]]])
+        [[0, 0, 1, 1, 0, 0],
+         [1, 0, 0, 0, 0, 1]],
+        [[1, 1, 1, 1, 1, 1],
+         [0, 0, 0, 0, 0, 0]]])
     predictions = constant_op.constant([
-      [[0, 0, 2, 1, 1, 0],
-       [0, 1, 2, 2, 0, 1]],
-      [[0, 0, 2, 1, 1, 1],
-       [1, 1, 2, 0, 0, 0]]])
+        [[0, 0, 2, 1, 1, 0],
+         [0, 1, 2, 2, 0, 1]],
+        [[0, 0, 2, 1, 1, 1],
+         [1, 1, 2, 0, 0, 0]]])
     num_classes = 3
     with self.test_session() as sess:
       miou, update_op = metrics.mean_iou(labels, predictions, num_classes)
       sess.run(variables.local_variables_initializer())
       self.assertAllEqual([[7, 4, 3], [3, 5, 2], [0, 0, 0]], update_op.eval())
       self.assertAlmostEqual(
-        1 / 3 * (7 / (7 + 3 + 7) + 5 / (5 + 4 + 5) + 0 / (0 + 5 + 0)),
-        miou.eval())
+          1 / 3 * (7 / (7 + 3 + 7) + 5 / (5 + 4 + 5) + 0 / (0 + 5 + 0)),
+          miou.eval())
 
   def testMissingClassOverallSmall(self):
     labels = constant_op.constant([0])
@@ -3599,22 +3599,22 @@ class MeanIOUTest(test.TestCase):
 
   def testMissingClassOverallLarge(self):
     labels = constant_op.constant([
-      [[0, 0, 1, 1, 0, 0],
-       [1, 0, 0, 0, 0, 1]],
-      [[1, 1, 1, 1, 1, 1],
-       [0, 0, 0, 0, 0, 0]]])
+        [[0, 0, 1, 1, 0, 0],
+         [1, 0, 0, 0, 0, 1]],
+        [[1, 1, 1, 1, 1, 1],
+         [0, 0, 0, 0, 0, 0]]])
     predictions = constant_op.constant([
-      [[0, 0, 1, 1, 0, 0],
-       [1, 1, 0, 0, 1, 1]],
-      [[0, 0, 0, 1, 1, 1],
-       [1, 1, 1, 0, 0, 0]]])
+        [[0, 0, 1, 1, 0, 0],
+         [1, 1, 0, 0, 1, 1]],
+        [[0, 0, 0, 1, 1, 1],
+         [1, 1, 1, 0, 0, 0]]])
     num_classes = 3
     with self.test_session() as sess:
       miou, update_op = metrics.mean_iou(labels, predictions, num_classes)
       sess.run(variables.local_variables_initializer())
       self.assertAllEqual([[9, 5, 0], [3, 7, 0], [0, 0, 0]], update_op.eval())
       self.assertAlmostEqual(
-        1 / 2 * (9 / (9 + 3 + 5) + 7 / (7 + 5 + 3)), miou.eval())
+          1 / 2 * (9 / (9 + 3 + 5) + 7 / (7 + 5 + 3)), miou.eval())
 
 
 class MeanPerClassAccuracyTest(test.TestCase):
diff --git a/tensorflow/python/kernel_tests/range_dataset_op_test.py b/tensorflow/python/kernel_tests/range_dataset_op_test.py
index 0c530522b8316e3c17716ad43c595b4af754e39c..3c1685c951fc75df12c0d4f5032d4888a55b2164 100644
--- a/tensorflow/python/kernel_tests/range_dataset_op_test.py
+++ b/tensorflow/python/kernel_tests/range_dataset_op_test.py
@@ -17,32 +17,15 @@ from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
-import os
-
 from tensorflow.python.data.ops import dataset_ops
-from tensorflow.python.data.ops import iterator_ops
 from tensorflow.python.framework import dtypes
 from tensorflow.python.framework import errors
-from tensorflow.python.framework import ops
-from tensorflow.python.framework import tensor_shape
 from tensorflow.python.ops import array_ops
-from tensorflow.python.ops import gen_dataset_ops
-from tensorflow.python.ops import io_ops
-from tensorflow.python.ops import parsing_ops
-from tensorflow.python.ops import variables
-from tensorflow.python.platform import gfile
 from tensorflow.python.platform import test
 
 
 class RangeDatasetTest(test.TestCase):
 
-  def tearDown(self):
-    # Remove all checkpoint files.
-    prefix = self._iterator_checkpoint_prefix()
-    pattern = prefix + "*"
-    files = gfile.Glob(pattern)
-    map(gfile.Remove, files)
-
   def testStop(self):
     stop = array_ops.placeholder(dtypes.int64, shape=[])
     iterator = dataset_ops.Dataset.range(stop).make_initializable_iterator()
@@ -168,319 +151,6 @@ class RangeDatasetTest(test.TestCase):
       with self.assertRaises(errors.OutOfRangeError):
         sess.run(get_next)
 
-  def _iterator_checkpoint_prefix(self):
-    return os.path.join(self.get_temp_dir(), "iterator")
-
-  def _save_op(self, iterator_resource):
-    iterator_state_variant = gen_dataset_ops.serialize_iterator(
-        iterator_resource)
-    save_op = io_ops.write_file(
-        self._iterator_checkpoint_prefix(),
-        parsing_ops.serialize_tensor(iterator_state_variant))
-    return save_op
-
-  def _restore_op(self, iterator_resource):
-    iterator_state_variant = parsing_ops.parse_tensor(
-        io_ops.read_file(self._iterator_checkpoint_prefix()), dtypes.variant)
-    restore_op = gen_dataset_ops.deserialize_iterator(iterator_resource,
-                                                      iterator_state_variant)
-    return restore_op
-
-  def testSaveRestore(self):
-
-    def _build_graph(start, stop):
-      iterator = dataset_ops.Dataset.range(start,
-                                           stop).make_initializable_iterator()
-      init_op = iterator.initializer
-      get_next = iterator.get_next()
-      save_op = self._save_op(iterator._iterator_resource)
-      restore_op = self._restore_op(iterator._iterator_resource)
-      return init_op, get_next, save_op, restore_op
-
-    # Saving and restoring in different sessions.
-    start = 2
-    stop = 10
-    break_point = 5
-    with ops.Graph().as_default() as g:
-      init_op, get_next, save_op, _ = _build_graph(start, stop)
-      with self.test_session(graph=g) as sess:
-        sess.run(variables.global_variables_initializer())
-        sess.run(init_op)
-        for i in range(start, break_point):
-          self.assertEqual(i, sess.run(get_next))
-        sess.run(save_op)
-
-    with ops.Graph().as_default() as g:
-      init_op, get_next, _, restore_op = _build_graph(start, stop)
-      with self.test_session(graph=g) as sess:
-        sess.run(init_op)
-        sess.run(restore_op)
-        for i in range(break_point, stop):
-          self.assertEqual(i, sess.run(get_next))
-        with self.assertRaises(errors.OutOfRangeError):
-          sess.run(get_next)
-
-    # Saving and restoring in same session.
-    with ops.Graph().as_default() as g:
-      init_op, get_next, save_op, restore_op = _build_graph(start, stop)
-      with self.test_session(graph=g) as sess:
-        sess.run(variables.global_variables_initializer())
-        sess.run(init_op)
-        for i in range(start, break_point):
-          self.assertEqual(i, sess.run(get_next))
-        sess.run(save_op)
-        sess.run(restore_op)
-        for i in range(break_point, stop):
-          self.assertEqual(i, sess.run(get_next))
-        with self.assertRaises(errors.OutOfRangeError):
-          sess.run(get_next)
-
-  def testRestoreWithoutBuildingDatasetGraph(self):
-
-    def _build_graph(start, stop, num_epochs):
-      dataset = dataset_ops.Dataset.range(start, stop).repeat(num_epochs)
-      iterator = dataset.make_initializable_iterator()
-      init_op = iterator.initializer
-      get_next = iterator.get_next()
-      save_op = self._save_op(iterator._iterator_resource)
-      restore_op = self._restore_op(iterator._iterator_resource)
-      return init_op, get_next, save_op, restore_op
-
-    # Saving and restoring in different sessions.
-    start = 2
-    stop = 10
-    num_epochs = 5
-    break_point = 5
-    break_epoch = 3
-    with ops.Graph().as_default() as g:
-      init_op, get_next, save_op, _ = _build_graph(start, stop, num_epochs)
-      with self.test_session(graph=g) as sess:
-        sess.run(variables.global_variables_initializer())
-        sess.run(init_op)
-        for _ in range(break_epoch):
-          for i in range(start, stop):
-            self.assertEqual(i, sess.run(get_next))
-        for i in range(start, break_point):
-          self.assertEqual(i, sess.run(get_next))
-        sess.run(save_op)
-
-    with ops.Graph().as_default() as g:
-      # Create an empty IteratorResource and restore the Iterator into it.
-      output_types = dtypes.int64
-      output_shapes = tensor_shape.scalar()
-      iterator = iterator_ops.Iterator.from_structure(output_types,
-                                                      output_shapes)
-      restore_op = self._restore_op(iterator._iterator_resource)
-      get_next = iterator.get_next()
-      with self.test_session(graph=g) as sess:
-        sess.run(restore_op)
-        for i in range(break_point, stop):
-          self.assertEqual(i, sess.run(get_next))
-        for _ in range(break_epoch + 1, num_epochs):
-          for i in range(start, stop):
-            self.assertEqual(i, sess.run(get_next))
-        with self.assertRaises(errors.OutOfRangeError):
-          sess.run(get_next)
-
-  def testRestoreInModifiedGraph(self):
-
-    def _build_graph(start, stop):
-      dataset = dataset_ops.Dataset.range(start, stop)
-      iterator = dataset.make_initializable_iterator()
-      init_op = iterator.initializer
-      get_next = iterator.get_next()
-      save_op = self._save_op(iterator._iterator_resource)
-      restore_op = self._restore_op(iterator._iterator_resource)
-      return init_op, get_next, save_op, restore_op
-
-    # Saving and restoring in different sessions.
-    start = 2
-    stop = 10
-    stop_1 = 8
-    break_point = 5
-    with ops.Graph().as_default() as g:
-      init_op, get_next, save_op, _ = _build_graph(start, stop)
-      with self.test_session(graph=g) as sess:
-        sess.run(variables.global_variables_initializer())
-        sess.run(init_op)
-        for i in range(start, break_point):
-          self.assertEqual(i, sess.run(get_next))
-        sess.run(save_op)
-
-    with ops.Graph().as_default() as g:
-      # Intentionally build a graph with a different value for stop to make sure
-      # the original dataset graph is actually getting loaded.
-      init_op, get_next, _, restore_op = _build_graph(start, stop_1)
-      with self.test_session(graph=g) as sess:
-        sess.run(restore_op)
-        for i in range(break_point, stop):
-          self.assertEqual(i, sess.run(get_next))
-        with self.assertRaises(errors.OutOfRangeError):
-          sess.run(get_next)
-
-  def testInitThenRestore(self):
-    # Note: Calling init_op before restore_op is redundant. This test just makes
-    # sure we do not fail if restore is called on an already initialized
-    # iterator resource.
-
-    def _build_graph(start, stop):
-      dataset = dataset_ops.Dataset.range(start, stop)
-      iterator = dataset.make_initializable_iterator()
-      init_op = iterator.initializer
-      get_next = iterator.get_next()
-      save_op = self._save_op(iterator._iterator_resource)
-      restore_op = self._restore_op(iterator._iterator_resource)
-      return init_op, get_next, save_op, restore_op
-
-    # Saving and restoring in different sessions.
-    start = 2
-    stop = 10
-    break_point = 5
-    with ops.Graph().as_default() as g:
-      init_op, get_next, save_op, _ = _build_graph(start, stop)
-      with self.test_session(graph=g) as sess:
-        sess.run(variables.global_variables_initializer())
-        sess.run(init_op)
-        for i in range(start, break_point):
-          self.assertEqual(i, sess.run(get_next))
-        sess.run(save_op)
-
-    with ops.Graph().as_default() as g:
-      init_op, get_next, _, restore_op = _build_graph(start, stop)
-      with self.test_session(graph=g) as sess:
-        sess.run(init_op)
-        sess.run(restore_op)
-        for i in range(break_point, stop):
-          self.assertEqual(i, sess.run(get_next))
-        with self.assertRaises(errors.OutOfRangeError):
-          sess.run(get_next)
-
-  def testMultipleSaves(self):
-
-    def _build_graph(start, stop):
-      iterator = dataset_ops.Dataset.range(start,
-                                           stop).make_initializable_iterator()
-      init_op = iterator.initializer
-      get_next = iterator.get_next()
-      save_op = self._save_op(iterator._iterator_resource)
-      restore_op = self._restore_op(iterator._iterator_resource)
-      return init_op, get_next, save_op, restore_op
-
-    start = 2
-    stop = 10
-    break_point1 = 5
-    break_point2 = 7
-
-    with ops.Graph().as_default() as g:
-      init_op, get_next, save_op, _ = _build_graph(start, stop)
-      with self.test_session(graph=g) as sess:
-        sess.run(variables.global_variables_initializer())
-        sess.run(init_op)
-        for i in range(start, break_point1):
-          self.assertEqual(i, sess.run(get_next))
-        sess.run(save_op)
-
-    with ops.Graph().as_default() as g:
-      init_op, get_next, save_op, restore_op = _build_graph(start, stop)
-      with self.test_session(graph=g) as sess:
-        sess.run(restore_op)
-        for i in range(break_point1, break_point2):
-          self.assertEqual(i, sess.run(get_next))
-        sess.run(save_op)
-
-    break_point2 = 7
-    with ops.Graph().as_default() as g:
-      init_op, get_next, save_op, restore_op = _build_graph(start, stop)
-      with self.test_session(graph=g) as sess:
-        sess.run(restore_op)
-        for i in range(break_point2, stop):
-          self.assertEqual(i, sess.run(get_next))
-        with self.assertRaises(errors.OutOfRangeError):
-          sess.run(get_next)
-
-  def testSaveRestoreWithRepeat(self):
-
-    def _build_graph(start, stop, num_epochs):
-      iterator = dataset_ops.Dataset.range(
-          start, stop).repeat(num_epochs).make_initializable_iterator()
-      init_op = iterator.initializer
-      get_next = iterator.get_next()
-      save_op = self._save_op(iterator._iterator_resource)
-      restore_op = self._restore_op(iterator._iterator_resource)
-      return init_op, get_next, save_op, restore_op
-
-    start = 2
-    stop = 10
-    num_epochs = 5
-    break_range = 5
-    break_epoch = 3
-    with ops.Graph().as_default() as g:
-      init_op, get_next, save_op, restore_op = _build_graph(
-          start, stop, num_epochs)
-      with self.test_session(graph=g) as sess:
-        sess.run(variables.global_variables_initializer())
-        sess.run(init_op)
-        # Note: There is no checkpoint saved currently so a NotFoundError is
-        # raised.
-        with self.assertRaises(errors.NotFoundError):
-          sess.run(restore_op)
-        for _ in range(break_epoch - 1):
-          for i in range(start, stop):
-            self.assertEqual(i, sess.run(get_next))
-        for i in range(start, break_range):
-          self.assertEqual(i, sess.run(get_next))
-        sess.run(save_op)
-
-    with ops.Graph().as_default() as g:
-      init_op, get_next, _, restore_op = _build_graph(start, stop, num_epochs)
-      with self.test_session(graph=g) as sess:
-        sess.run(restore_op)
-        for i in range(break_range, stop):
-          self.assertEqual(i, sess.run(get_next))
-        for _ in range(break_epoch, num_epochs):
-          for i in range(start, stop):
-            self.assertEqual(i, sess.run(get_next))
-        with self.assertRaises(errors.OutOfRangeError):
-          sess.run(get_next)
-
-  def testSaveRestoreExhaustedIterator(self):
-
-    def _build_graph(start, stop, num_epochs):
-      iterator = dataset_ops.Dataset.range(
-          start, stop).repeat(num_epochs).make_initializable_iterator()
-      init_op = iterator.initializer
-      get_next = iterator.get_next()
-      save_op = self._save_op(iterator._iterator_resource)
-      restore_op = self._restore_op(iterator._iterator_resource)
-      return init_op, get_next, save_op, restore_op
-
-    start = 2
-    stop = 10
-    num_epochs = 5
-    with ops.Graph().as_default() as g:
-      init_op, get_next, save_op, restore_op = _build_graph(
-          start, stop, num_epochs)
-      with self.test_session(graph=g) as sess:
-        sess.run(variables.global_variables_initializer())
-        sess.run(init_op)
-        # Note: There is no checkpoint saved currently so a NotFoundError is
-        # raised.
-        with self.assertRaises(errors.NotFoundError):
-          sess.run(restore_op)
-        for _ in range(num_epochs):
-          for i in range(start, stop):
-            self.assertEqual(i, sess.run(get_next))
-        with self.assertRaises(errors.OutOfRangeError):
-          sess.run(get_next)
-        sess.run(save_op)
-
-    with ops.Graph().as_default() as g:
-      init_op, get_next, _, restore_op = _build_graph(start, stop, num_epochs)
-      with self.test_session(graph=g) as sess:
-        sess.run(restore_op)
-        with self.assertRaises(errors.OutOfRangeError):
-          sess.run(get_next)
-
 
 if __name__ == "__main__":
   test.main()
diff --git a/tensorflow/python/kernel_tests/reader_dataset_ops_test.py b/tensorflow/python/kernel_tests/reader_dataset_ops_test.py
index c8e7333b4b9949b6b6ef5f7f6d63e5ff8c354c37..70b6ce442ea597b9b002e495c17ad3357e5663e0 100644
--- a/tensorflow/python/kernel_tests/reader_dataset_ops_test.py
+++ b/tensorflow/python/kernel_tests/reader_dataset_ops_test.py
@@ -26,13 +26,8 @@ from tensorflow.python.data.ops import readers
 from tensorflow.python.framework import constant_op
 from tensorflow.python.framework import dtypes
 from tensorflow.python.framework import errors
-from tensorflow.python.framework import ops
-from tensorflow.python.framework import tensor_shape
 from tensorflow.python.lib.io import python_io
 from tensorflow.python.ops import array_ops
-from tensorflow.python.ops import gen_dataset_ops
-from tensorflow.python.ops import io_ops
-from tensorflow.python.ops import parsing_ops
 from tensorflow.python.platform import test
 from tensorflow.python.util import compat
 
@@ -272,299 +267,6 @@ class FixedLengthRecordReaderTest(test.TestCase):
       with self.assertRaises(errors.OutOfRangeError):
         sess.run(iterator.get_next())
 
-  def _iterator_checkpoint_path(self):
-    return os.path.join(self.get_temp_dir(), "iterator")
-
-  def _save_op(self, iterator_resource):
-    iterator_state_variant = gen_dataset_ops.serialize_iterator(
-        iterator_resource)
-    save_op = io_ops.write_file(
-        self._iterator_checkpoint_path(),
-        parsing_ops.serialize_tensor(iterator_state_variant))
-    return save_op
-
-  def _restore_op(self, iterator_resource):
-    iterator_state_variant = parsing_ops.parse_tensor(
-        io_ops.read_file(self._iterator_checkpoint_path()), dtypes.variant)
-    restore_op = gen_dataset_ops.deserialize_iterator(iterator_resource,
-                                                      iterator_state_variant)
-    return restore_op
-
-  def _build_iterator_graph(self, num_epochs):
-    filenames = self._createFiles()
-    dataset = (readers.FixedLengthRecordDataset(
-        filenames, self._record_bytes, self._header_bytes, self._footer_bytes)
-               .repeat(num_epochs))
-    iterator = dataset.make_initializable_iterator()
-    init_op = iterator.initializer
-    get_next_op = iterator.get_next()
-    save_op = self._save_op(iterator._iterator_resource)
-    restore_op = self._restore_op(iterator._iterator_resource)
-    return init_op, get_next_op, save_op, restore_op
-
-  def _restore_iterator(self):
-    output_types = dtypes.string
-    output_shapes = tensor_shape.scalar()
-    iterator = iterator_ops.Iterator.from_structure(output_types, output_shapes)
-    get_next = iterator.get_next()
-    restore_op = self._restore_op(iterator._iterator_resource)
-    return restore_op, get_next
-
-  def testSaveRestore(self):
-    num_epochs = 10
-    epoch_break = 5
-    file_break = self._num_files // 2
-    record_break = self._num_records // 2
-
-    with ops.Graph().as_default() as g:
-      init_op, get_next_op, save_op, restore_op = self._build_iterator_graph(
-          num_epochs=num_epochs)
-      with self.test_session(graph=g) as sess:
-        sess.run(init_op)
-        # Note: There is no checkpoint saved currently so a NotFoundError is
-        # raised.
-        with self.assertRaises(errors.NotFoundError):
-          sess.run(restore_op)
-        for epoch in range(num_epochs):
-          for f in range(self._num_files):
-            for r in range(self._num_records):
-              if (epoch == epoch_break and f == file_break and
-                  r == record_break):
-                sess.run(save_op)
-                break
-              self.assertEqual(self._record(f, r), sess.run(get_next_op))
-            else:
-              continue
-            break
-          else:
-            continue
-          break
-        else:
-          with self.assertRaises(errors.OutOfRangeError):
-            sess.run(get_next_op)
-
-    with ops.Graph().as_default() as g:
-      init_op, get_next_op, save_op, restore_op = self._build_iterator_graph(
-          num_epochs=num_epochs)
-      with self.test_session(graph=g) as sess:
-        sess.run(restore_op)
-        for epoch in range(num_epochs):
-          for f in range(self._num_files):
-            for r in range(self._num_records):
-              if (epoch < epoch_break or
-                  (epoch == epoch_break and f < file_break) or
-                  (epoch == epoch_break and f == file_break and
-                   r < record_break)):
-                continue
-              self.assertEqual(self._record(f, r), sess.run(get_next_op))
-        with self.assertRaises(errors.OutOfRangeError):
-          sess.run(get_next_op)
-
-  def testInitThenRestore(self):
-    # Note: Calling init_op before restore_op is redundant. This test just makes
-    # sure we do not fail if restore is called on an already initialized
-    # iterator resource.
-    num_epochs = 10
-    epoch_break = 5
-    file_break = self._num_files // 2
-    record_break = self._num_records // 2
-
-    with ops.Graph().as_default() as g:
-      init_op, get_next_op, save_op, restore_op = self._build_iterator_graph(
-          num_epochs=num_epochs)
-      with self.test_session(graph=g) as sess:
-        sess.run(init_op)
-        # Note: There is no checkpoint saved currently so a NotFoundError is
-        # raised.
-        with self.assertRaises(errors.NotFoundError):
-          sess.run(restore_op)
-        for epoch in range(num_epochs):
-          for f in range(self._num_files):
-            for r in range(self._num_records):
-              if (epoch == epoch_break and f == file_break and
-                  r == record_break):
-                sess.run(save_op)
-                break
-              self.assertEqual(self._record(f, r), sess.run(get_next_op))
-            else:
-              continue
-            break
-          else:
-            continue
-          break
-        else:
-          with self.assertRaises(errors.OutOfRangeError):
-            sess.run(get_next_op)
-
-    with ops.Graph().as_default() as g:
-      init_op, get_next_op, save_op, restore_op = self._build_iterator_graph(
-          num_epochs=num_epochs)
-      with self.test_session(graph=g) as sess:
-        sess.run(init_op)
-        sess.run(restore_op)
-        for epoch in range(num_epochs):
-          for f in range(self._num_files):
-            for r in range(self._num_records):
-              if (epoch < epoch_break or
-                  (epoch == epoch_break and f < file_break) or
-                  (epoch == epoch_break and f == file_break and
-                   r < record_break)):
-                continue
-              self.assertEqual(self._record(f, r), sess.run(get_next_op))
-        with self.assertRaises(errors.OutOfRangeError):
-          sess.run(get_next_op)
-
-  def testRestoreInModifiedGraph(self):
-    num_epochs = 10
-    num_epochs_1 = 20
-    epoch_break = 5
-    file_break = self._num_files // 2
-    record_break = self._num_records // 2
-
-    with ops.Graph().as_default() as g:
-      init_op, get_next_op, save_op, restore_op = self._build_iterator_graph(
-          num_epochs=num_epochs)
-      with self.test_session(graph=g) as sess:
-        sess.run(init_op)
-        # Note: There is no checkpoint saved currently so a NotFoundError is
-        # raised.
-        with self.assertRaises(errors.NotFoundError):
-          sess.run(restore_op)
-        for epoch in range(num_epochs):
-          for f in range(self._num_files):
-            for r in range(self._num_records):
-              if (epoch == epoch_break and f == file_break and
-                  r == record_break):
-                sess.run(save_op)
-                break
-              self.assertEqual(self._record(f, r), sess.run(get_next_op))
-            else:
-              continue
-            break
-          else:
-            continue
-          break
-        else:
-          with self.assertRaises(errors.OutOfRangeError):
-            sess.run(get_next_op)
-
-    with ops.Graph().as_default() as g:
-      init_op, get_next_op, save_op, restore_op = self._build_iterator_graph(
-          num_epochs=num_epochs_1)
-      with self.test_session(graph=g) as sess:
-        sess.run(restore_op)
-        for epoch in range(num_epochs):
-          for f in range(self._num_files):
-            for r in range(self._num_records):
-              if (epoch < epoch_break or
-                  (epoch == epoch_break and f < file_break) or
-                  (epoch == epoch_break and f == file_break and
-                   r < record_break)):
-                continue
-              self.assertEqual(self._record(f, r), sess.run(get_next_op))
-        with self.assertRaises(errors.OutOfRangeError):
-          sess.run(get_next_op)
-
-  def testRestoreWithoutBuildingDatasetGraph(self):
-    num_epochs = 10
-    epoch_break = 5
-    file_break = self._num_files // 2
-    record_break = self._num_records // 2
-
-    with ops.Graph().as_default() as g:
-      init_op, get_next_op, save_op, restore_op = self._build_iterator_graph(
-          num_epochs=num_epochs)
-      with self.test_session(graph=g) as sess:
-        sess.run(init_op)
-        # Note: There is no checkpoint saved currently so a NotFoundError is
-        # raised.
-        with self.assertRaises(errors.NotFoundError):
-          sess.run(restore_op)
-        for epoch in range(num_epochs):
-          for f in range(self._num_files):
-            for r in range(self._num_records):
-              if (epoch == epoch_break and f == file_break and
-                  r == record_break):
-                sess.run(save_op)
-                break
-              self.assertEqual(self._record(f, r), sess.run(get_next_op))
-            else:
-              continue
-            break
-          else:
-            continue
-          break
-        else:
-          with self.assertRaises(errors.OutOfRangeError):
-            sess.run(get_next_op)
-
-    with ops.Graph().as_default() as g:
-      restore_op, get_next_op = self._restore_iterator()
-      with self.test_session(graph=g) as sess:
-        sess.run(restore_op)
-        for epoch in range(num_epochs):
-          for f in range(self._num_files):
-            for r in range(self._num_records):
-              if (epoch < epoch_break or
-                  (epoch == epoch_break and f < file_break) or
-                  (epoch == epoch_break and f == file_break and
-                   r < record_break)):
-                continue
-              self.assertEqual(self._record(f, r), sess.run(get_next_op))
-        with self.assertRaises(errors.OutOfRangeError):
-          sess.run(get_next_op)
-
-  def testRestoreUnusedIterator(self):
-    num_epochs = 10
-    with ops.Graph().as_default() as g:
-      init_op, get_next_op, save_op, restore_op = self._build_iterator_graph(
-          num_epochs=num_epochs)
-      with self.test_session(graph=g) as sess:
-        sess.run(init_op)
-        # Note: There is no checkpoint saved currently so a NotFoundError is
-        # raised.
-        with self.assertRaises(errors.NotFoundError):
-          sess.run(restore_op)
-        # Save unused iterator.
-        sess.run(save_op)
-    with ops.Graph().as_default() as g:
-      init_op, get_next_op, save_op, restore_op = self._build_iterator_graph(
-          num_epochs=num_epochs)
-      with self.test_session(graph=g) as sess:
-        sess.run(restore_op)
-        for _ in range(num_epochs * self._num_files * self._num_records):
-          sess.run(get_next_op)
-        with self.assertRaises(errors.OutOfRangeError):
-          sess.run(get_next_op)
-
-  def testRestoreExhaustedIterator(self):
-    num_epochs = 10
-
-    with ops.Graph().as_default() as g:
-      init_op, get_next_op, save_op, restore_op = self._build_iterator_graph(
-          num_epochs=num_epochs)
-      with self.test_session(graph=g) as sess:
-        sess.run(init_op)
-        # Note: There is no checkpoint saved currently so a NotFoundError is
-        # raised.
-        with self.assertRaises(errors.NotFoundError):
-          sess.run(restore_op)
-        for _ in range(num_epochs):
-          for f in range(self._num_files):
-            for r in range(self._num_records):
-              self.assertEqual(self._record(f, r), sess.run(get_next_op))
-        with self.assertRaises(errors.OutOfRangeError):
-          sess.run(get_next_op)
-        sess.run(save_op)
-
-    with ops.Graph().as_default() as g:
-      init_op, get_next_op, save_op, restore_op = self._build_iterator_graph(
-          num_epochs=num_epochs)
-      with self.test_session(graph=g) as sess:
-        sess.run(restore_op)
-        with self.assertRaises(errors.OutOfRangeError):
-          sess.run(get_next_op)
-
 
 class TFRecordDatasetTest(test.TestCase):
 
diff --git a/tensorflow/python/kernel_tests/segment_reduction_ops_test.py b/tensorflow/python/kernel_tests/segment_reduction_ops_test.py
index 516a9d000e91f55d595ee9dc9cf633fd578942b1..3a02f249028c134158802e55c38d6bef46184000 100644
--- a/tensorflow/python/kernel_tests/segment_reduction_ops_test.py
+++ b/tensorflow/python/kernel_tests/segment_reduction_ops_test.py
@@ -323,8 +323,9 @@ class UnsortedSegmentSumTest(SegmentReductionHelper):
   def testBadIndices(self):
     # Note: GPU kernel does not return the out-of-range error needed for this
     # test, so this test is marked as cpu-only.
+    # Note: With PR #13055 a negative index will be ignored silently.
     with self.test_session(use_gpu=False):
-      for bad in [[-1]], [[7]]:
+      for bad in [[2]], [[7]]:
         unsorted = math_ops.unsorted_segment_sum([[17]], bad, num_segments=2)
         with self.assertRaisesOpError(
             r"segment_ids\[0,0\] = %d is out of range \[0, 2\)" % bad[0][0]):
@@ -360,6 +361,32 @@ class UnsortedSegmentSumTest(SegmentReductionHelper):
             x_init_value=np_x.astype(np.double), delta=1)
       self.assertAllClose(jacob_t, jacob_n)
 
+  def testDropNegatives(self):
+    # Note: the test is done by replacing segment_ids with 8 to -1
+    # for index  and replace values generated by numpy with 0.
+    dtypes = [
+        dtypes_lib.float32, dtypes_lib.float64, dtypes_lib.int64,
+        dtypes_lib.int32, dtypes_lib.complex64, dtypes_lib.complex128
+    ]
+    indices_flat = np.array([0, 4, 0, 8, 3, 8, 4, 7, 7, 3])
+    num_segments = 12
+    for indices in indices_flat, indices_flat.reshape(5, 2):
+      shape = indices.shape + (2,)
+      for dtype in dtypes:
+        with self.test_session(use_gpu=True):
+          tf_x, np_x = self._input(shape, dtype=dtype)
+          np_ans = self._segmentReduce(
+              indices, np_x, np.add, op2=None, num_out_rows=num_segments)
+          # Replace np_ans[8] with 0 for the value
+          np_ans[8:] = 0
+          # Replace 8 with -1 in indices
+          np.place(indices, indices==8, [-1])
+          s = math_ops.unsorted_segment_sum(
+              data=tf_x, segment_ids=indices, num_segments=num_segments)
+          tf_ans = s.eval()
+        self.assertAllClose(np_ans, tf_ans)
+        self.assertShapeEqual(np_ans, s)
+
 
 class SparseSegmentReductionHelper(SegmentReductionHelper):
 
diff --git a/tensorflow/python/kernel_tests/spacetodepth_op_test.py b/tensorflow/python/kernel_tests/spacetodepth_op_test.py
index 4a9353d6bf8b5471e6f1769efe0ecfab250d5e88..3c98a685e07a1f2d55c3c1035a99ffaa593d35b3 100644
--- a/tensorflow/python/kernel_tests/spacetodepth_op_test.py
+++ b/tensorflow/python/kernel_tests/spacetodepth_op_test.py
@@ -277,11 +277,15 @@ class SpaceToDepthTest(test.TestCase):
 class SpaceToDepthGradientTest(test.TestCase):
 
   # Check the gradients.
-  def _checkGrad(self, x, block_size):
+  def _checkGrad(self, x, block_size, data_format):
+    # NCHW is implemented for only GPU.
+    if data_format == "NCHW" and not test.is_gpu_available():
+      return
+
     assert 4 == x.ndim
     with self.test_session(use_gpu=True):
       tf_x = ops.convert_to_tensor(x)
-      tf_y = array_ops.space_to_depth(tf_x, block_size)
+      tf_y = array_ops.space_to_depth(tf_x, block_size, data_format=data_format)
       epsilon = 1e-2
       ((x_jacob_t, x_jacob_n)) = gradient_checker.compute_gradient(
           tf_x,
@@ -295,23 +299,28 @@ class SpaceToDepthGradientTest(test.TestCase):
 
   # Tests a gradient for space_to_depth of x which is a four dimensional
   # tensor of shape [b, h * block_size, w * block_size, d].
-  def _compare(self, b, h, w, d, block_size):
+  def _compare(self, b, h, w, d, block_size, data_format):
     block_size_sq = block_size * block_size
-    x = np.random.normal(0, 1, b * h * w * d *
-                         block_size_sq).astype(np.float32).reshape(
-                             [b, h * block_size, w * block_size, d])
+    data = np.random.normal(0, 1, b * h * w * d * block_size_sq).astype(
+        np.float32)
+    if data_format == "NHWC":
+      x = data.reshape([b, h * block_size, w * block_size, d])
+    else:
+      x = data.reshape([b, d, h * block_size, w * block_size])
 
-    self._checkGrad(x, block_size)
+    self._checkGrad(x, block_size, data_format)
 
   # Don't use very large numbers as dimensions here as the result is tensor
   # with cartesian product of the dimensions.
   def testSmall(self):
     block_size = 2
-    self._compare(1, 2, 3, 5, block_size)
+    self._compare(1, 2, 3, 5, block_size, "NHWC")
+    self._compare(1, 2, 3, 5, block_size, "NCHW")
 
   def testSmall2(self):
     block_size = 2
-    self._compare(2, 4, 3, 2, block_size)
+    self._compare(2, 4, 3, 2, block_size, "NHWC")
+    self._compare(2, 4, 3, 2, block_size, "NCHW")
 
 
 if __name__ == "__main__":
diff --git a/tensorflow/python/kernel_tests/tensor_array_ops_test.py b/tensorflow/python/kernel_tests/tensor_array_ops_test.py
index a1fc6d63d454c6130874da948a2c84a3e4384b20..0f3b11e7f9f4a4ce1e828b64a069a0647d69baff 100644
--- a/tensorflow/python/kernel_tests/tensor_array_ops_test.py
+++ b/tensorflow/python/kernel_tests/tensor_array_ops_test.py
@@ -169,18 +169,22 @@ class TensorArrayTest(test.TestCase):
     self._testTensorArrayWriteConcat(dtypes.complex128)
     self._testTensorArrayWriteConcat(dtypes.string)
 
-  def _testTensorArrayPackNotAllValuesAvailableFails(self):
+  def _testTensorArrayReadOrPackNotAllValuesAvailableFillsZeros(self):
     with self.test_session(use_gpu=True):
       ta = tensor_array_ops.TensorArray(
-          dtype=dtypes.float32, tensor_array_name="foo", size=3)
-
-      with self.assertRaisesOpError("Could not read from TensorArray index 1 "
-                                    "because it has not yet been written to."):
-        self.evaluate(ta.write(0, [[4.0, 5.0]]).stack())
+          dtype=dtypes.float32,
+          tensor_array_name="foo",
+          size=3,
+          element_shape=tensor_shape.TensorShape([1, 2]))
+      self.assertAllEqual([[0.0, 0.0]], self.evaluate(ta.read(0)))
+      self.assertAllEqual([[[0.0, 0.0]], [[4.0, 5.0]], [[0.0, 0.0]]],
+                          self.evaluate(ta.write(1, [[4.0, 5.0]]).stack()))
+      self.assertAllEqual([[0.0, 0.0], [4.0, 5.0], [0.0, 0.0]],
+                          self.evaluate(ta.write(1, [[4.0, 5.0]]).concat()))
 
   @test_util.run_in_graph_and_eager_modes()
-  def testTensorArrayPackNotAllValuesAvailableFails(self):
-    self._testTensorArrayPackNotAllValuesAvailableFails()
+  def testTensorArrayReadOrPackNotAllValuesAvailableFillsZeros(self):
+    self._testTensorArrayReadOrPackNotAllValuesAvailableFillsZeros()
 
   def _testTensorArrayUnpackRead(self, tf_dtype):
     with self.test_session(use_gpu=True):
@@ -423,12 +427,6 @@ class TensorArrayTest(test.TestCase):
             "TensorArray dtype is float but Op requested dtype double."):
           r0_bad.eval()
 
-      # Test reading from a different index than the one we wrote to
-      with self.assertRaisesOpError(
-          "Could not read from TensorArray index 1 because "
-          "it has not yet been written to."):
-        self.evaluate(w0.read(1))
-
       # Test reading from a negative index, which is not allowed
       if context.in_graph_mode():
         with self.assertRaisesOpError(
diff --git a/tensorflow/python/lib/core/py_seq_tensor.cc b/tensorflow/python/lib/core/py_seq_tensor.cc
index 3b40e1c94c01f95af2d3f2728547bd5f244ff21f..71cb38f8fd24beeb9efe149a6bd39e0ef2031051 100644
--- a/tensorflow/python/lib/core/py_seq_tensor.cc
+++ b/tensorflow/python/lib/core/py_seq_tensor.cc
@@ -36,13 +36,7 @@ inline PyObject* PyType(PyObject* obj) {
 }
 
 bool IsPyString(PyObject* obj) {
-  // TODO(josh11b): Support unicode strings in Python 2? bytearrays? NumPy string
-  // types?
-#if PY_MAJOR_VERSION >= 3
   return PyBytes_Check(obj) || PyUnicode_Check(obj);
-#else
-  return PyBytes_Check(obj);
-#endif
 }
 
 bool IsPyInt(PyObject* obj) {
@@ -309,15 +303,21 @@ const char* ConvertOneString(PyObject* v, string* out) {
     out->assign(PyBytes_AS_STRING(v), PyBytes_GET_SIZE(v));
     return nullptr;
   }
-#if PY_MAJOR_VERSION >= 3
   if (PyUnicode_Check(v)) {
+#if PY_MAJOR_VERSION >= 3
     Py_ssize_t size;
     const char* str = PyUnicode_AsUTF8AndSize(v, &size);
     if (str == nullptr) return ErrorConvertingUnicodeString;
     out->assign(str, size);
     return nullptr;
-  }
+#else
+    PyObject* py_str = PyUnicode_AsUTF8String(v);
+    if (py_str == nullptr) return ErrorConvertingUnicodeString;
+    out->assign(PyBytes_AS_STRING(py_str), PyBytes_GET_SIZE(py_str));
+    Py_DECREF(py_str);
+    return nullptr;
 #endif
+  }
   return ErrorMixedTypes;
 }
 
diff --git a/tensorflow/python/ops/array_grad.py b/tensorflow/python/ops/array_grad.py
index 7e632c75e80da4d32d94fb1b0192e2aa7657a4fe..3c025881cb8b56b2109b31cceb0699f33bbc0566 100644
--- a/tensorflow/python/ops/array_grad.py
+++ b/tensorflow/python/ops/array_grad.py
@@ -641,14 +641,22 @@ def _BatchToSpaceNDGrad(op, grad):
 def _SpaceToDepthGrad(op, grad):
   # Its gradient is the opposite op: DepthToSpace.
   block_size = op.get_attr("block_size")
-  return array_ops.depth_to_space(grad, block_size)
+  data_format = op.get_attr("data_format")
+  if data_format == "NCHW_VECT_C":
+    raise ValueError("Cannot compute SpaceToDepth gradient with NCHW_VECT_C. "
+                     "NCHW_VECT_C requires qint8 data type.")
+  return array_ops.depth_to_space(grad, block_size, data_format=data_format)
 
 
 @ops.RegisterGradient("DepthToSpace")
 def _DepthToSpaceGrad(op, grad):
   # Its gradient is the opposite op: SpaceToDepth.
   block_size = op.get_attr("block_size")
-  return array_ops.space_to_depth(grad, block_size)
+  data_format = op.get_attr("data_format")
+  if data_format == "NCHW_VECT_C":
+    raise ValueError("Cannot compute DepthToSpace gradient with NCHW_VECT_C. "
+                     "NCHW_VECT_C requires qint8 data type.")
+  return array_ops.space_to_depth(grad, block_size, data_format=data_format)
 
 
 ops.NotDifferentiable("OneHot")
diff --git a/tensorflow/python/ops/distributions/dirichlet.py b/tensorflow/python/ops/distributions/dirichlet.py
index 923696a553caae80592be65f7ffeecb3f9373bb0..2accedf1b963f01034f0b4059f44e46eb9bfc5ab 100644
--- a/tensorflow/python/ops/distributions/dirichlet.py
+++ b/tensorflow/python/ops/distributions/dirichlet.py
@@ -196,7 +196,7 @@ class Dirichlet(distribution.Distribution):
         alpha=self.concentration,
         dtype=self.dtype,
         seed=seed)
-    return gamma_sample / math_ops.reduce_sum(gamma_sample, -1, keep_dims=True)
+    return gamma_sample / math_ops.reduce_sum(gamma_sample, -1, keepdims=True)
 
   @distribution_util.AppendDocstring(_dirichlet_sample_note)
   def _log_prob(self, x):
diff --git a/tensorflow/python/ops/distributions/special_math.py b/tensorflow/python/ops/distributions/special_math.py
index 6b38a4958e463cbf157196efa26d27e7e23b4369..222a39ad8284cf95e271097fa8ac478125ee329c 100644
--- a/tensorflow/python/ops/distributions/special_math.py
+++ b/tensorflow/python/ops/distributions/special_math.py
@@ -197,9 +197,10 @@ def _ndtri(p):
   # Write in an arbitrary value in place of 0 for p since 0 will cause NaNs
   # later on. The result from the computation when p == 0 is not used so any
   # number that doesn't result in NaNs is fine.
+  one_half = constant_op.constant(0.5, dtype=p.dtype)
   sanitized_mcp = array_ops.where(
       maybe_complement_p <= 0.,
-      0.5 * array_ops.ones_like(p),
+      array_ops.fill(array_ops.shape(p), one_half),
       maybe_complement_p)
 
   # Compute x for p > exp(-2): x/sqrt(2pi) = w + w**3 P0(w**2)/Q0(w**2).
@@ -226,7 +227,8 @@ def _ndtri(p):
                       array_ops.where(z >= 8.0, x_for_small_p, x_otherwise))
 
   x = array_ops.where(p > 1. - np.exp(-2.), x, -x)
-  infinity = constant_op.constant(np.inf, dtype=x.dtype) * array_ops.ones_like(x)
+  infinity_scalar = constant_op.constant(np.inf, dtype=p.dtype)
+  infinity = array_ops.fill(array_ops.shape(p), infinity_scalar)
   x_nan_replaced = array_ops.where(
       p <= 0.0, -infinity, array_ops.where(p >= 1.0, infinity, x))
   return x_nan_replaced
diff --git a/tensorflow/python/ops/hidden_ops.txt b/tensorflow/python/ops/hidden_ops.txt
index 732ab8f15ab8ce7873d5454ff42cdf939cd6e5bd..a0fff9e16cdb489aa4950b050ebbd6e08236eac8 100644
--- a/tensorflow/python/ops/hidden_ops.txt
+++ b/tensorflow/python/ops/hidden_ops.txt
@@ -223,6 +223,7 @@ BatchSelfAdjointEig
 BatchSelfAdjointEigV2
 BatchSvd
 LogMatrixDeterminant
+MatrixExponential
 MatrixSolveLs
 SelfAdjointEig
 SelfAdjointEigV2
diff --git a/tensorflow/python/ops/image_ops_impl.py b/tensorflow/python/ops/image_ops_impl.py
index 2946dbe81e6d37930874689d5c95fcdbadbbc68d..474a20d7cf578272e335ae74915aa971827a2bde 100644
--- a/tensorflow/python/ops/image_ops_impl.py
+++ b/tensorflow/python/ops/image_ops_impl.py
@@ -1121,7 +1121,7 @@ def rgb_to_grayscale(images, name=None):
     rank_1 = array_ops.expand_dims(array_ops.rank(images) - 1, 0)
     gray_float = math_ops.reduce_sum(flt_image * rgb_weights,
                                      rank_1,
-                                     keep_dims=True)
+                                     keepdims=True)
     gray_float.set_shape(images.get_shape()[:-1].concatenate([1]))
     return convert_image_dtype(gray_float, orig_dtype, name=name)
 
diff --git a/tensorflow/python/ops/linalg/linalg_impl.py b/tensorflow/python/ops/linalg/linalg_impl.py
index 04a15e3e5bc548f99bd5d4ad1fcbf0fa22b4d1ef..bf15f0e2e55385032b194c7718e175114e77dd7b 100644
--- a/tensorflow/python/ops/linalg/linalg_impl.py
+++ b/tensorflow/python/ops/linalg/linalg_impl.py
@@ -38,6 +38,7 @@ diag_part = array_ops.matrix_diag_part
 eigh = linalg_ops.self_adjoint_eig
 eigvalsh = linalg_ops.self_adjoint_eigvals
 einsum = special_math_ops.einsum
+expm = gen_linalg_ops._matrix_exponential
 eye = linalg_ops.eye
 inv = linalg_ops.matrix_inverse
 lstsq = linalg_ops.matrix_solve_ls
diff --git a/tensorflow/python/ops/linalg_ops.py b/tensorflow/python/ops/linalg_ops.py
index 2cb467c89157b2f78c5bc3ccc037360836b00ee7..14a039ffd0aeae8fb7a186a2039f25550dcd7d1b 100644
--- a/tensorflow/python/ops/linalg_ops.py
+++ b/tensorflow/python/ops/linalg_ops.py
@@ -30,6 +30,7 @@ from tensorflow.python.ops import math_ops
 from tensorflow.python.ops.gen_linalg_ops import *
 # pylint: enable=wildcard-import
 from tensorflow.python.util import compat
+from tensorflow.python.util.deprecation import deprecated_args
 
 # Names below are lower_case.
 # pylint: disable=invalid-name
@@ -438,7 +439,10 @@ def svd(tensor, full_matrices=False, compute_uv=True, name=None):
 
 
 # pylint: disable=redefined-builtin
-def norm(tensor, ord='euclidean', axis=None, keep_dims=False, name=None):
+@deprecated_args(None, "keep_dims is deprecated, use keepdims instead",
+                 "keep_dims")
+def norm(tensor, ord='euclidean', axis=None, keepdims=None, name=None,
+         keep_dims=None):
   r"""Computes the norm of vectors, matrices, and tensors.
 
   This function can compute several different vector norms (the 1-norm, the
@@ -471,13 +475,13 @@ def norm(tensor, ord='euclidean', axis=None, keep_dims=False, name=None):
       can be either a matrix or a batch of matrices at runtime, pass
       `axis=[-2,-1]` instead of `axis=None` to make sure that matrix norms are
       computed.
-    keep_dims: If True, the axis indicated in `axis` are kept with size 1.
+    keepdims: If True, the axis indicated in `axis` are kept with size 1.
       Otherwise, the dimensions in `axis` are removed from the output shape.
     name: The name of the op.
 
   Returns:
     output: A `Tensor` of the same type as tensor, containing the vector or
-      matrix norms. If `keep_dims` is True then the rank of output is equal to
+      matrix norms. If `keepdims` is True then the rank of output is equal to
       the rank of `tensor`. Otherwise, if `axis` is none the output is a scalar,
       if `axis` is an integer, the rank of `output` is one less than the rank
       of `tensor`, if `axis` is a 2-tuple the rank of `output` is two less
@@ -497,6 +501,13 @@ def norm(tensor, ord='euclidean', axis=None, keep_dims=False, name=None):
   @end_compatibility
   """
 
+  if keep_dims is not None:
+    if keepdims is not None:
+      raise ValueError("Cannot specify both 'keep_dims' and 'keepdims'")
+    keepdims = keep_dims
+  if keepdims is None:
+    keepdims = False
+
   is_matrix_norm = ((isinstance(axis, tuple) or isinstance(axis, list)) and
                     len(axis) == 2)
   if is_matrix_norm:
@@ -528,25 +539,25 @@ def norm(tensor, ord='euclidean', axis=None, keep_dims=False, name=None):
       # matrices.
       result = math_ops.sqrt(
           math_ops.reduce_sum(
-              tensor * math_ops.conj(tensor), axis, keep_dims=True))
+              tensor * math_ops.conj(tensor), axis, keepdims=True))
     else:
       result = math_ops.abs(tensor)
       if ord == 1:
         sum_axis = None if axis is None else axis[0]
-        result = math_ops.reduce_sum(result, sum_axis, keep_dims=True)
+        result = math_ops.reduce_sum(result, sum_axis, keepdims=True)
         if is_matrix_norm:
-          result = math_ops.reduce_max(result, axis[-1], keep_dims=True)
+          result = math_ops.reduce_max(result, axis[-1], keepdims=True)
       elif ord == np.inf:
         if is_matrix_norm:
-          result = math_ops.reduce_sum(result, axis[1], keep_dims=True)
+          result = math_ops.reduce_sum(result, axis[1], keepdims=True)
         max_axis = None if axis is None else axis[0]
-        result = math_ops.reduce_max(result, max_axis, keep_dims=True)
+        result = math_ops.reduce_max(result, max_axis, keepdims=True)
       else:
         # General p-norms (positive p only)
         result = math_ops.pow(
             math_ops.reduce_sum(
-                math_ops.pow(result, ord), axis, keep_dims=True), 1.0 / ord)
-    if not keep_dims:
+                math_ops.pow(result, ord), axis, keepdims=True), 1.0 / ord)
+    if not keepdims:
       result = array_ops.squeeze(result, axis)
     return result
 
diff --git a/tensorflow/python/ops/math_ops.py b/tensorflow/python/ops/math_ops.py
index 9db4b0d8cc392508b7d1ef25bfd2cf685dd07c5f..13c0eeba65b770431a18266e1538608467299b0a 100644
--- a/tensorflow/python/ops/math_ops.py
+++ b/tensorflow/python/ops/math_ops.py
@@ -89,6 +89,7 @@ See the @{$python/math_ops} guide.
 @@matrix_inverse
 @@cholesky
 @@cholesky_solve
+@@matrix_exponential
 @@matrix_solve
 @@matrix_triangular_solve
 @@matrix_solve_ls
@@ -1264,16 +1265,19 @@ def _ReductionDims(x, axis, reduction_indices):
     return range(0, array_ops.rank(x))
 
 
+@deprecated_args(None, "keep_dims is deprecated, use keepdims instead",
+                 "keep_dims")
 def reduce_sum(input_tensor,
                axis=None,
-               keep_dims=False,
+               keepdims=None,
                name=None,
-               reduction_indices=None):
+               reduction_indices=None,
+               keep_dims=None):
   """Computes the sum of elements across dimensions of a tensor.
 
   Reduces `input_tensor` along the dimensions given in `axis`.
-  Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
-  entry in `axis`. If `keep_dims` is true, the reduced dimensions
+  Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
+  entry in `axis`. If `keepdims` is true, the reduced dimensions
   are retained with length 1.
 
   If `axis` has no entries, all dimensions are reduced, and a
@@ -1286,7 +1290,7 @@ def reduce_sum(input_tensor,
   tf.reduce_sum(x)  # 6
   tf.reduce_sum(x, 0)  # [2, 2, 2]
   tf.reduce_sum(x, 1)  # [3, 3]
-  tf.reduce_sum(x, 1, keep_dims=True)  # [[3], [3]]
+  tf.reduce_sum(x, 1, keepdims=True)  # [[3], [3]]
   tf.reduce_sum(x, [0, 1])  # 6
   ```
 
@@ -1295,7 +1299,7 @@ def reduce_sum(input_tensor,
     axis: The dimensions to reduce. If `None` (the default),
       reduces all dimensions. Must be in the range
       `[-rank(input_tensor), rank(input_tensor))`.
-    keep_dims: If true, retains reduced dimensions with length 1.
+    keepdims: If true, retains reduced dimensions with length 1.
     name: A name for the operation (optional).
     reduction_indices: The old (deprecated) name for axis.
 
@@ -1306,24 +1310,35 @@ def reduce_sum(input_tensor,
   Equivalent to np.sum
   @end_compatibility
   """
+
+  if keep_dims is not None:
+    if keepdims is not None:
+      raise ValueError("Cannot specify both 'keep_dims' and 'keepdims'")
+    keepdims = keep_dims
+  if keepdims is None:
+    keepdims = False
+
   return gen_math_ops._sum(
       input_tensor,
       _ReductionDims(input_tensor, axis, reduction_indices),
-      keep_dims,
+      keepdims,
       name=name)
 
 
+@deprecated_args(None, "keep_dims is deprecated, use keepdims instead",
+                 "keep_dims")
 def count_nonzero(input_tensor,
                   axis=None,
-                  keep_dims=False,
+                  keepdims=None,
                   dtype=dtypes.int64,
                   name=None,
-                  reduction_indices=None):
+                  reduction_indices=None,
+                  keep_dims=None):
   """Computes number of nonzero elements across dimensions of a tensor.
 
   Reduces `input_tensor` along the dimensions given in `axis`.
-  Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
-  entry in `axis`. If `keep_dims` is true, the reduced dimensions
+  Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
+  entry in `axis`. If `keepdims` is true, the reduced dimensions
   are retained with length 1.
 
   If `axis` has no entries, all dimensions are reduced, and a
@@ -1340,7 +1355,7 @@ def count_nonzero(input_tensor,
   tf.count_nonzero(x)  # 3
   tf.count_nonzero(x, 0)  # [1, 2, 0]
   tf.count_nonzero(x, 1)  # [1, 2]
-  tf.count_nonzero(x, 1, keep_dims=True)  # [[1], [2]]
+  tf.count_nonzero(x, 1, keepdims=True)  # [[1], [2]]
   tf.count_nonzero(x, [0, 1])  # 3
   ```
 
@@ -1349,7 +1364,7 @@ def count_nonzero(input_tensor,
     axis: The dimensions to reduce. If `None` (the default),
       reduces all dimensions. Must be in the range
       `[-rank(input_tensor), rank(input_tensor))`.
-    keep_dims: If true, retains reduced dimensions with length 1.
+    keepdims: If true, retains reduced dimensions with length 1.
     dtype: The output dtype; defaults to `tf.int64`.
     name: A name for the operation (optional).
     reduction_indices: The old (deprecated) name for axis.
@@ -1357,6 +1372,13 @@ def count_nonzero(input_tensor,
   Returns:
     The reduced tensor (number of nonzero values).
   """
+  if keep_dims is not None:
+    if keepdims is not None:
+      raise ValueError("Cannot specify both 'keep_dims' and 'keepdims'")
+    keepdims = keep_dims
+  if keepdims is None:
+    keepdims = False
+
   with ops.name_scope(name, "count_nonzero", [input_tensor]):
     input_tensor = ops.convert_to_tensor(input_tensor, name="input_tensor")
     zero = input_tensor.dtype.as_numpy_dtype()
@@ -1365,21 +1387,24 @@ def count_nonzero(input_tensor,
             # int64 reduction happens on GPU
             to_int64(gen_math_ops.not_equal(input_tensor, zero)),
             axis=axis,
-            keep_dims=keep_dims,
+            keepdims=keepdims,
             reduction_indices=reduction_indices),
         dtype=dtype)
 
 
+@deprecated_args(None, "keep_dims is deprecated, use keepdims instead",
+                 "keep_dims")
 def reduce_mean(input_tensor,
                 axis=None,
-                keep_dims=False,
+                keepdims=None,
                 name=None,
-                reduction_indices=None):
+                reduction_indices=None,
+                keep_dims=None):
   """Computes the mean of elements across dimensions of a tensor.
 
   Reduces `input_tensor` along the dimensions given in `axis`.
-  Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
-  entry in `axis`. If `keep_dims` is true, the reduced dimensions
+  Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
+  entry in `axis`. If `keepdims` is true, the reduced dimensions
   are retained with length 1.
 
   If `axis` has no entries, all dimensions are reduced, and a
@@ -1399,7 +1424,7 @@ def reduce_mean(input_tensor,
     axis: The dimensions to reduce. If `None` (the default),
       reduces all dimensions. Must be in the range
       `[-rank(input_tensor), rank(input_tensor))`.
-    keep_dims: If true, retains reduced dimensions with length 1.
+    keepdims: If true, retains reduced dimensions with length 1.
     name: A name for the operation (optional).
     reduction_indices: The old (deprecated) name for axis.
 
@@ -1410,23 +1435,32 @@ def reduce_mean(input_tensor,
   Equivalent to np.mean
   @end_compatibility
   """
+  if keep_dims is not None:
+    if keepdims is not None:
+      raise ValueError("Cannot specify both 'keep_dims' and 'keepdims'")
+    keepdims = keep_dims
+  if keepdims is None:
+    keepdims = False
   return gen_math_ops._mean(
       input_tensor,
       _ReductionDims(input_tensor, axis, reduction_indices),
-      keep_dims,
+      keepdims,
       name=name)
 
 
+@deprecated_args(None, "keep_dims is deprecated, use keepdims instead",
+                 "keep_dims")
 def reduce_prod(input_tensor,
                 axis=None,
-                keep_dims=False,
+                keepdims=None,
                 name=None,
-                reduction_indices=None):
+                reduction_indices=None,
+                keep_dims=None):
   """Computes the product of elements across dimensions of a tensor.
 
   Reduces `input_tensor` along the dimensions given in `axis`.
-  Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
-  entry in `axis`. If `keep_dims` is true, the reduced dimensions
+  Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
+  entry in `axis`. If `keepdims` is true, the reduced dimensions
   are retained with length 1.
 
   If `axis` has no entries, all dimensions are reduced, and a
@@ -1437,7 +1471,7 @@ def reduce_prod(input_tensor,
     axis: The dimensions to reduce. If `None` (the default),
       reduces all dimensions. Must be in the range
       `[-rank(input_tensor), rank(input_tensor))`.
-    keep_dims: If true, retains reduced dimensions with length 1.
+    keepdims: If true, retains reduced dimensions with length 1.
     name: A name for the operation (optional).
     reduction_indices: The old (deprecated) name for axis.
 
@@ -1448,23 +1482,32 @@ def reduce_prod(input_tensor,
   Equivalent to np.prod
   @end_compatibility
   """
+  if keep_dims is not None:
+    if keepdims is not None:
+      raise ValueError("Cannot specify both 'keep_dims' and 'keepdims'")
+    keepdims = keep_dims
+  if keepdims is None:
+    keepdims = False
   return gen_math_ops._prod(
       input_tensor,
       _ReductionDims(input_tensor, axis, reduction_indices),
-      keep_dims,
+      keepdims,
       name=name)
 
 
+@deprecated_args(None, "keep_dims is deprecated, use keepdims instead",
+                 "keep_dims")
 def reduce_min(input_tensor,
                axis=None,
-               keep_dims=False,
+               keepdims=None,
                name=None,
-               reduction_indices=None):
+               reduction_indices=None,
+               keep_dims=None):
   """Computes the minimum of elements across dimensions of a tensor.
 
   Reduces `input_tensor` along the dimensions given in `axis`.
-  Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
-  entry in `axis`. If `keep_dims` is true, the reduced dimensions
+  Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
+  entry in `axis`. If `keepdims` is true, the reduced dimensions
   are retained with length 1.
 
   If `axis` has no entries, all dimensions are reduced, and a
@@ -1475,7 +1518,7 @@ def reduce_min(input_tensor,
     axis: The dimensions to reduce. If `None` (the default),
       reduces all dimensions. Must be in the range
       `[-rank(input_tensor), rank(input_tensor))`.
-    keep_dims: If true, retains reduced dimensions with length 1.
+    keepdims: If true, retains reduced dimensions with length 1.
     name: A name for the operation (optional).
     reduction_indices: The old (deprecated) name for axis.
 
@@ -1486,23 +1529,32 @@ def reduce_min(input_tensor,
   Equivalent to np.min
   @end_compatibility
   """
+  if keep_dims is not None:
+    if keepdims is not None:
+      raise ValueError("Cannot specify both 'keep_dims' and 'keepdims'")
+    keepdims = keep_dims
+  if keepdims is None:
+    keepdims = False
   return gen_math_ops._min(
       input_tensor,
       _ReductionDims(input_tensor, axis, reduction_indices),
-      keep_dims,
+      keepdims,
       name=name)
 
 
+@deprecated_args(None, "keep_dims is deprecated, use keepdims instead",
+                 "keep_dims")
 def reduce_max(input_tensor,
                axis=None,
-               keep_dims=False,
+               keepdims=None,
                name=None,
-               reduction_indices=None):
+               reduction_indices=None,
+               keep_dims=None):
   """Computes the maximum of elements across dimensions of a tensor.
 
   Reduces `input_tensor` along the dimensions given in `axis`.
-  Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
-  entry in `axis`. If `keep_dims` is true, the reduced dimensions
+  Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
+  entry in `axis`. If `keepdims` is true, the reduced dimensions
   are retained with length 1.
 
   If `axis` has no entries, all dimensions are reduced, and a
@@ -1513,7 +1565,7 @@ def reduce_max(input_tensor,
     axis: The dimensions to reduce. If `None` (the default),
       reduces all dimensions. Must be in the range
       `[-rank(input_tensor), rank(input_tensor))`.
-    keep_dims: If true, retains reduced dimensions with length 1.
+    keepdims: If true, retains reduced dimensions with length 1.
     name: A name for the operation (optional).
     reduction_indices: The old (deprecated) name for axis.
 
@@ -1524,23 +1576,32 @@ def reduce_max(input_tensor,
   Equivalent to np.max
   @end_compatibility
   """
+  if keep_dims is not None:
+    if keepdims is not None:
+      raise ValueError("Cannot specify both 'keep_dims' and 'keepdims'")
+    keepdims = keep_dims
+  if keepdims is None:
+    keepdims = False
   return gen_math_ops._max(
       input_tensor,
       _ReductionDims(input_tensor, axis, reduction_indices),
-      keep_dims,
+      keepdims,
       name=name)
 
 
+@deprecated_args(None, "keep_dims is deprecated, use keepdims instead",
+                 "keep_dims")
 def reduce_all(input_tensor,
                axis=None,
-               keep_dims=False,
+               keepdims=None,
                name=None,
-               reduction_indices=None):
+               reduction_indices=None,
+               keep_dims=None):
   """Computes the "logical and" of elements across dimensions of a tensor.
 
   Reduces `input_tensor` along the dimensions given in `axis`.
-  Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
-  entry in `axis`. If `keep_dims` is true, the reduced dimensions
+  Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
+  entry in `axis`. If `keepdims` is true, the reduced dimensions
   are retained with length 1.
 
   If `axis` has no entries, all dimensions are reduced, and a
@@ -1560,7 +1621,7 @@ def reduce_all(input_tensor,
     axis: The dimensions to reduce. If `None` (the default),
       reduces all dimensions. Must be in the range
       `[-rank(input_tensor), rank(input_tensor))`.
-    keep_dims: If true, retains reduced dimensions with length 1.
+    keepdims: If true, retains reduced dimensions with length 1.
     name: A name for the operation (optional).
     reduction_indices: The old (deprecated) name for axis.
 
@@ -1571,23 +1632,32 @@ def reduce_all(input_tensor,
   Equivalent to np.all
   @end_compatibility
   """
+  if keep_dims is not None:
+    if keepdims is not None:
+      raise ValueError("Cannot specify both 'keep_dims' and 'keepdims'")
+    keepdims = keep_dims
+  if keepdims is None:
+    keepdims = False
   return gen_math_ops._all(
       input_tensor,
       _ReductionDims(input_tensor, axis, reduction_indices),
-      keep_dims,
+      keepdims,
       name=name)
 
 
+@deprecated_args(None, "keep_dims is deprecated, use keepdims instead",
+                 "keep_dims")
 def reduce_any(input_tensor,
                axis=None,
-               keep_dims=False,
+               keepdims=None,
                name=None,
-               reduction_indices=None):
+               reduction_indices=None,
+               keep_dims=None):
   """Computes the "logical or" of elements across dimensions of a tensor.
 
   Reduces `input_tensor` along the dimensions given in `axis`.
-  Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
-  entry in `axis`. If `keep_dims` is true, the reduced dimensions
+  Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
+  entry in `axis`. If `keepdims` is true, the reduced dimensions
   are retained with length 1.
 
   If `axis` has no entries, all dimensions are reduced, and a
@@ -1607,7 +1677,7 @@ def reduce_any(input_tensor,
     axis: The dimensions to reduce. If `None` (the default),
       reduces all dimensions. Must be in the range
       `[-rank(input_tensor), rank(input_tensor))`.
-    keep_dims: If true, retains reduced dimensions with length 1.
+    keepdims: If true, retains reduced dimensions with length 1.
     name: A name for the operation (optional).
     reduction_indices: The old (deprecated) name for axis.
 
@@ -1618,23 +1688,32 @@ def reduce_any(input_tensor,
   Equivalent to np.any
   @end_compatibility
   """
+  if keep_dims is not None:
+    if keepdims is not None:
+      raise ValueError("Cannot specify both 'keep_dims' and 'keepdims'")
+    keepdims = keep_dims
+  if keepdims is None:
+    keepdims = False
   return gen_math_ops._any(
       input_tensor,
       _ReductionDims(input_tensor, axis, reduction_indices),
-      keep_dims,
+      keepdims,
       name=name)
 
 
+@deprecated_args(None, "keep_dims is deprecated, use keepdims instead",
+                 "keep_dims")
 def reduce_logsumexp(input_tensor,
                      axis=None,
-                     keep_dims=False,
+                     keepdims=None,
                      name=None,
-                     reduction_indices=None):
+                     reduction_indices=None,
+                     keep_dims=None):
   """Computes log(sum(exp(elements across dimensions of a tensor))).
 
   Reduces `input_tensor` along the dimensions given in `axis`.
-  Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
-  entry in `axis`. If `keep_dims` is true, the reduced dimensions
+  Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
+  entry in `axis`. If `keepdims` is true, the reduced dimensions
   are retained with length 1.
 
   If `axis` has no entries, all dimensions are reduced, and a
@@ -1651,7 +1730,7 @@ def reduce_logsumexp(input_tensor,
   tf.reduce_logsumexp(x)  # log(6)
   tf.reduce_logsumexp(x, 0)  # [log(2), log(2), log(2)]
   tf.reduce_logsumexp(x, 1)  # [log(3), log(3)]
-  tf.reduce_logsumexp(x, 1, keep_dims=True)  # [[log(3)], [log(3)]]
+  tf.reduce_logsumexp(x, 1, keepdims=True)  # [[log(3)], [log(3)]]
   tf.reduce_logsumexp(x, [0, 1])  # log(6)
   ```
 
@@ -1660,19 +1739,25 @@ def reduce_logsumexp(input_tensor,
     axis: The dimensions to reduce. If `None` (the default),
       reduces all dimensions. Must be in the range
       `[-rank(input_tensor), rank(input_tensor))`.
-    keep_dims: If true, retains reduced dimensions with length 1.
+    keepdims: If true, retains reduced dimensions with length 1.
     name: A name for the operation (optional).
     reduction_indices: The old (deprecated) name for axis.
 
   Returns:
     The reduced tensor.
   """
+  if keep_dims is not None:
+    if keepdims is not None:
+      raise ValueError("Cannot specify both 'keep_dims' and 'keepdims'")
+    keepdims = keep_dims
+  if keepdims is None:
+    keepdims = False
   with ops.name_scope(name, "ReduceLogSumExp", [input_tensor]) as name:
     raw_max = reduce_max(
         input_tensor,
         axis=axis,
         reduction_indices=reduction_indices,
-        keep_dims=True)
+        keepdims=True)
     my_max = array_ops.stop_gradient(
         array_ops.where(
             gen_math_ops.is_finite(raw_max),
@@ -1682,9 +1767,9 @@ def reduce_logsumexp(input_tensor,
         reduce_sum(
             gen_math_ops.exp(input_tensor - my_max),
             axis,
-            keep_dims=True,
+            keepdims=True,
             reduction_indices=reduction_indices)) + my_max
-    if not keep_dims:
+    if not keepdims:
       if isinstance(axis, int):
         axis = [axis]
       result = array_ops.squeeze(result, axis)
@@ -2356,7 +2441,7 @@ def reduced_shape(input_shape, axes):
     input_shape: 1-D Tensor, the shape of the Tensor being reduced.
     axes: 1-D Tensor, the reduction axes.
   Returns:
-    A 1-D Tensor, the output shape as if keep_dims were set to True.
+    A 1-D Tensor, the output shape as if keepdims were set to True.
   """
   # Example:
   # cast needed for SparseTensor reductions
diff --git a/tensorflow/python/ops/metrics.py b/tensorflow/python/ops/metrics.py
index 14e486a84e89cce895fdf4fee0c650e828d9edb8..7e75542aec3e117510b810bad7f92af2084ae3b3 100644
--- a/tensorflow/python/ops/metrics.py
+++ b/tensorflow/python/ops/metrics.py
@@ -39,7 +39,9 @@
 @@root_mean_squared_error
 @@sensitivity_at_specificity
 @@sparse_average_precision_at_k
+@@average_precision_at_k
 @@sparse_precision_at_k
+@@precision_at_k
 @@precision_at_top_k
 @@specificity_at_sensitivity
 @@true_negatives
diff --git a/tensorflow/python/ops/metrics_impl.py b/tensorflow/python/ops/metrics_impl.py
index 47f072652ef5f14baf1cc70b6bf2b4c6dbac8508..870c4f40623a5ded717920dccfecfc1ac0d9909b 100644
--- a/tensorflow/python/ops/metrics_impl.py
+++ b/tensorflow/python/ops/metrics_impl.py
@@ -33,6 +33,7 @@ from tensorflow.python.ops import sparse_ops
 from tensorflow.python.ops import state_ops
 from tensorflow.python.ops import variable_scope
 from tensorflow.python.ops import weights_broadcast_ops
+from tensorflow.python.util.deprecation import deprecated
 
 
 def metric_variable(shape, dtype, validate_shape=True, name=None):
@@ -793,7 +794,7 @@ def mean_cosine_distance(labels, predictions, dim, weights=None,
   radial_diffs = math_ops.multiply(predictions, labels)
   radial_diffs = math_ops.reduce_sum(radial_diffs,
                                      reduction_indices=[dim,],
-                                     keep_dims=True)
+                                     keepdims=True)
   mean_distance, update_op = mean(radial_diffs, weights,
                                   None,
                                   None,
@@ -2835,6 +2836,7 @@ def _streaming_sparse_average_precision_at_top_k(labels,
     return mean_average_precision, update
 
 
+@deprecated(None, 'Use average_precision_at_k instead')
 def sparse_average_precision_at_k(labels,
                                   predictions,
                                   k,
@@ -2842,9 +2844,27 @@ def sparse_average_precision_at_k(labels,
                                   metrics_collections=None,
                                   updates_collections=None,
                                   name=None):
+  """Renamed to `average_precision_at_k`, please use that method instead."""
+  return average_precision_at_k(
+      labels=labels,
+      predictions=predictions,
+      k=k,
+      weights=weights,
+      metrics_collections=metrics_collections,
+      updates_collections=updates_collections,
+      name=name)
+
+
+def average_precision_at_k(labels,
+                           predictions,
+                           k,
+                           weights=None,
+                           metrics_collections=None,
+                           updates_collections=None,
+                           name=None):
   """Computes average precision@k of predictions with respect to sparse labels.
 
-  `sparse_average_precision_at_k` creates two local variables,
+  `average_precision_at_k` creates two local variables,
   `average_precision_at_<k>/total` and `average_precision_at_<k>/max`, that
   are used to compute the frequency. This frequency is ultimately returned as
   `average_precision_at_<k>`: an idempotent operation that simply divides
@@ -3088,6 +3108,7 @@ def precision_at_top_k(labels,
     return metric, update
 
 
+@deprecated(None, 'Use precision_at_k instead')
 def sparse_precision_at_k(labels,
                           predictions,
                           k,
@@ -3096,6 +3117,26 @@ def sparse_precision_at_k(labels,
                           metrics_collections=None,
                           updates_collections=None,
                           name=None):
+  """Renamed to `precision_at_k`, please use that method instead."""
+  return precision_at_k(
+      labels=labels,
+      predictions=predictions,
+      k=k,
+      class_id=class_id,
+      weights=weights,
+      metrics_collections=metrics_collections,
+      updates_collections=updates_collections,
+      name=name)
+
+
+def precision_at_k(labels,
+                   predictions,
+                   k,
+                   class_id=None,
+                   weights=None,
+                   metrics_collections=None,
+                   updates_collections=None,
+                   name=None):
   """Computes precision@k of the predictions with respect to sparse labels.
 
   If `class_id` is specified, we calculate precision by considering only the
@@ -3106,7 +3147,7 @@ def sparse_precision_at_k(labels,
       average a class among the top-k classes with the highest predicted values
       of a batch entry is correct and can be found in the label for that entry.
 
-  `sparse_precision_at_k` creates two local variables,
+  `precision_at_k` creates two local variables,
   `true_positive_at_<k>` and `false_positive_at_<k>`, that are used to compute
   the precision@k frequency. This frequency is ultimately returned as
   `precision_at_<k>`: an idempotent operation that simply divides
diff --git a/tensorflow/python/ops/resource_variable_ops.py b/tensorflow/python/ops/resource_variable_ops.py
index 9e5bb4a225e091d14936a209b82f3d250dee8359..a746735f58fedd1b52744772f54a68aeec3df3ef 100644
--- a/tensorflow/python/ops/resource_variable_ops.py
+++ b/tensorflow/python/ops/resource_variable_ops.py
@@ -63,7 +63,7 @@ def _eager_safe_variable_handle(shape, dtype, shared_name, name, graph_mode):
     raise ValueError("variable object with name '%s' already created. Use "
                      "get_variable() if reuse is desired." %
                      shared_name)
-  with context.graph_mode(), ops.Graph().as_default():
+  with context.graph_mode(), ops.Graph().as_default() as graph:
     h = gen_resource_variable_ops.var_handle_op(shape=shape, dtype=dtype,
                                                 shared_name=shared_name,
                                                 name=name,
@@ -74,6 +74,25 @@ def _eager_safe_variable_handle(shape, dtype, shared_name, name, graph_mode):
     # shape inference doesn't run in eager mode we copy this data here for when
     # the handle is captured by an eager mode function.
     handle._handle_data = h._handle_data  # pylint: disable=protected-access
+  # Clean up our reference cycles to avoid making the garbage collector run.
+  # pylint: disable=protected-access
+  # OrderedDict, constructed on Graph creation, makes a simple reference loop
+  # and hides it in an __attribute in some Python versions. We don't need to
+  # throw an error if we can't find it, but if we do find it we can break the
+  # loop to avoid creating work for the garbage collector.
+  problematic_cycle = graph._functions.__dict__.get("_OrderedDict__root", None)
+  # pylint: enable=protected-access
+  if problematic_cycle:
+    try:
+      del problematic_cycle[0][:]
+    except TypeError:
+      # This is probably not one of the problematic Python versions. Continue
+      # with the rest of our cleanup.
+      pass
+  # Now clean up our own reference cycles by clearing all of the attributes for
+  # the Graph and op we created.
+  h.__dict__ = {}
+  graph.__dict__ = {}
   return handle
 
 
@@ -454,6 +473,7 @@ class ResourceVariable(variables.Variable):
           ops.add_to_collections(collections, self)
         elif ops.GraphKeys.GLOBAL_STEP in collections:
           ops.add_to_collections(ops.GraphKeys.GLOBAL_STEP, self)
+
     if not self._in_graph_mode:
       # After the handle has been created, set up a way to clean it up when
       # executing eagerly. We'll hold the only reference to the deleter, so that
diff --git a/tensorflow/python/ops/tensor_array_ops.py b/tensorflow/python/ops/tensor_array_ops.py
index b4b7ad9d9104a2168b61ad6c3062e125be507747..ea5354c1d6a6db27c1221b64359dce0082c43e3b 100644
--- a/tensorflow/python/ops/tensor_array_ops.py
+++ b/tensorflow/python/ops/tensor_array_ops.py
@@ -593,10 +593,7 @@ class _EagerTensorArray(object):
             "a previous read (perhaps try setting clear_after_read = false?)" %
             index)
       else:
-        raise errors_impl.InvalidArgumentError(
-            None, None,
-            "Could not read from TensorArray index %d because it has not yet "
-            "been written to." % index)
+        tensor = self._maybe_zero(index)
 
     if self._clear_after_read:
       self._tensor_array[index] = None
@@ -610,52 +607,36 @@ class _EagerTensorArray(object):
     _eager_write_no_copy(ta._implementation, index, value)  # pylint: disable=protected-access
     return ta
 
+  def _maybe_zero(self, ix):
+    val = self._tensor_array[ix]
+    if val is None:
+      val = self._tensor_array[ix] = array_ops.zeros(
+          shape=self._element_shape, dtype=self._dtype)
+    return val
+
   def stack(self, name=None):
     """See TensorArray."""
-    try:
-      return array_ops.stack(self._tensor_array, name=name)
-    except ValueError:
-      if None in self._tensor_array:
-        idx = self._tensor_array.index(None)
-        raise errors_impl.InvalidArgumentError(
-            None, None, "Could not read from TensorArray index %d because "
-            "it has not yet been written to." % idx)
-      else:
-        raise
+    if self._tensor_array:
+      for ix in range(len(self._tensor_array)):
+        self._maybe_zero(ix)
+    return array_ops.stack(self._tensor_array, name=name)
 
   def gather(self, indices, name=None):
     """See TensorArray."""
     del name  # not meaningful in Eager mode
-    return array_ops.stack([self._tensor_array[i] for i in indices.numpy()])
+    return array_ops.stack([self._maybe_zero(i) for i in indices.numpy()])
 
   def concat(self, name=None):
     """See TensorArray."""
     try:
-      return array_ops.concat(self._tensor_array, 0, name=name)
+      return array_ops.concat(
+          [self._maybe_zero(ix) for ix in range(len(self._tensor_array))],
+          0, name=name)
     except errors_impl.OpError:
       # Reproduce a subset of the error-handling for graph-mode TensorArrays.
       shapes = [t.shape for t in self._tensor_array]
       ndims = [s.ndims for s in shapes]
-      if None in self._tensor_array:
-        # Concatenating empty TensorArrays is permitted if the element
-        # shape is defined; the output is a tensor with shape
-        # [0] + self._element_shape[1:]
-        if all(t is None for t in self._tensor_array):
-          if self._element_shape is not None:
-            return constant_op.constant([], shape=[0] + self._element_shape[1:])
-          else:
-            raise errors_impl.UnimplementedError(
-                None, None, "TensorArray has size zero, but "
-                "element_shape_except0 %s is not fully defined. Currently only "
-                "static shapes are supported when concatenating zero-size "
-                "TensorArrays." % self._element_shape[1:])
-        # Concatenating a TensorArray in which some but not all entries have
-        # been written to is not allowed.
-        idx = self._tensor_array.index(None)
-        raise errors_impl.InvalidArgumentError(
-            None, None, "Could not read from TensorArray index %d because "
-            "it has not yet been written to." % idx)
-      elif 0 in ndims:
+      if 0 in ndims:
         idx = ndims.index(0)
         raise errors_impl.InvalidArgumentError(
             None, None, "Concat saw a scalar shape at index %d but requires "
diff --git a/tensorflow/python/platform/app.py b/tensorflow/python/platform/app.py
index 5ecaa1baafb3dc6bb6d5f234f261837f64612c4e..c01e1c9b1a0cbd097f1239b03623355abb317dbd 100644
--- a/tensorflow/python/platform/app.py
+++ b/tensorflow/python/platform/app.py
@@ -18,6 +18,7 @@ from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
+import errno as _errno
 import sys as _sys
 
 from tensorflow.python.platform import flags
@@ -28,24 +29,108 @@ def _benchmark_tests_can_log_memory():
   return True
 
 
+def _usage(shorthelp):
+  """Writes __main__'s docstring to stdout with some help text.
+
+  Args:
+    shorthelp: bool, if True, prints only flags from the main module,
+        rather than all flags.
+  """
+  doc = _sys.modules['__main__'].__doc__
+  if not doc:
+    doc = '\nUSAGE: %s [flags]\n' % _sys.argv[0]
+    doc = flags.text_wrap(doc, indent='       ', firstline_indent='')
+  else:
+    # Replace all '%s' with sys.argv[0], and all '%%' with '%'.
+    num_specifiers = doc.count('%') - 2 * doc.count('%%')
+    try:
+      doc %= (_sys.argv[0],) * num_specifiers
+    except (OverflowError, TypeError, ValueError):
+      # Just display the docstring as-is.
+      pass
+  if shorthelp:
+    flag_str = flags.FLAGS.main_module_help()
+  else:
+    flag_str = str(flags.FLAGS)
+  try:
+    _sys.stdout.write(doc)
+    if flag_str:
+      _sys.stdout.write('\nflags:\n')
+      _sys.stdout.write(flag_str)
+    _sys.stdout.write('\n')
+  except IOError as e:
+    # We avoid printing a huge backtrace if we get EPIPE, because
+    # "foo.par --help | less" is a frequent use case.
+    if e.errno != _errno.EPIPE:
+      raise
+
+
+class _HelpFlag(flags.BooleanFlag):
+  """Special boolean flag that displays usage and raises SystemExit."""
+  NAME = 'help'
+  SHORT_NAME = 'h'
+
+  def __init__(self):
+    super(_HelpFlag, self).__init__(
+        self.NAME, False, 'show this help', short_name=self.SHORT_NAME)
+
+  def parse(self, arg):
+    if arg:
+      _usage(shorthelp=True)
+      print()
+      print('Try --helpfull to get a list of all flags.')
+      _sys.exit(1)
+
+
+class _HelpshortFlag(_HelpFlag):
+  """--helpshort is an alias for --help."""
+  NAME = 'helpshort'
+  SHORT_NAME = None
+
+
+class _HelpfullFlag(flags.BooleanFlag):
+  """Display help for flags in main module and all dependent modules."""
+
+  def __init__(self):
+    super(_HelpfullFlag, self).__init__('helpfull', False, 'show full help')
+
+  def parse(self, arg):
+    if arg:
+      _usage(shorthelp=False)
+      _sys.exit(1)
+
+
+_define_help_flags_called = False
+
+
+def _define_help_flags():
+  global _define_help_flags_called
+  if not _define_help_flags_called:
+    flags.DEFINE_flag(_HelpFlag())
+    flags.DEFINE_flag(_HelpfullFlag())
+    flags.DEFINE_flag(_HelpshortFlag())
+    _define_help_flags_called = True
+
+
 def run(main=None, argv=None):
   """Runs the program with an optional 'main' function and 'argv' list."""
-  f = flags.FLAGS
 
-  # Extract the args from the optional `argv` list.
-  args = argv[1:] if argv else None
+  # Define help flags.
+  _define_help_flags()
 
-  # Parse the known flags from that list, or from the command
-  # line otherwise.
-  # pylint: disable=protected-access
-  flags_passthrough = f._parse_flags(args=args)
-  # pylint: enable=protected-access
+  # Parse flags.
+  try:
+    argv = flags.FLAGS(_sys.argv if argv is None else argv)
+  except flags.Error as error:
+    _sys.stderr.write('FATAL Flags parsing error: %s\n' % error)
+    _sys.stderr.write('Pass --helpshort or --helpfull to see help on flags.\n')
+    _sys.exit(1)
 
   main = main or _sys.modules['__main__'].main
 
   # Call the main function, passing through any arguments
   # to the final program.
-  _sys.exit(main(_sys.argv[:1] + flags_passthrough))
+  _sys.exit(main(argv))
 
 
 _allowed_symbols = [
diff --git a/tensorflow/python/platform/flags.py b/tensorflow/python/platform/flags.py
index 138a0ced97bc03c491b0282fc56f25a575093684..e9a36ae75d6ce4763ff83c97bec008a4da0897b0 100644
--- a/tensorflow/python/platform/flags.py
+++ b/tensorflow/python/platform/flags.py
@@ -13,199 +13,10 @@
 # limitations under the License.
 # ==============================================================================
 
-"""Implementation of the flags interface."""
+"""Import router for absl.flags. See https://github.com/abseil/abseil-py."""
 from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
-import argparse as _argparse
-
-from tensorflow.python.platform import tf_logging as _logging
-from tensorflow.python.util.all_util import remove_undocumented
-
-_global_parser = _argparse.ArgumentParser()
-
-
-# pylint: disable=invalid-name
-
-
-class _FlagValues(object):
-  """Global container and accessor for flags and their values."""
-
-  def __init__(self):
-    self.__dict__['__flags'] = {}
-    self.__dict__['__parsed'] = False
-    self.__dict__['__required_flags'] = set()
-
-  def _parse_flags(self, args=None):
-    result, unparsed = _global_parser.parse_known_args(args=args)
-    for flag_name, val in vars(result).items():
-      self.__dict__['__flags'][flag_name] = val
-    self.__dict__['__parsed'] = True
-    self._assert_all_required()
-    return unparsed
-
-  def __getattr__(self, name):
-    """Retrieves the 'value' attribute of the flag --name."""
-    try:
-      parsed = self.__dict__['__parsed']
-    except KeyError:
-      # May happen during pickle.load or copy.copy
-      raise AttributeError(name)
-    if not parsed:
-      self._parse_flags()
-    if name not in self.__dict__['__flags']:
-      raise AttributeError(name)
-    return self.__dict__['__flags'][name]
-
-  def __setattr__(self, name, value):
-    """Sets the 'value' attribute of the flag --name."""
-    if not self.__dict__['__parsed']:
-      self._parse_flags()
-    self.__dict__['__flags'][name] = value
-    self._assert_required(name)
-
-  def _add_required_flag(self, item):
-    self.__dict__['__required_flags'].add(item)
-
-  def _assert_required(self, flag_name):
-    if (flag_name not in self.__dict__['__flags'] or
-        self.__dict__['__flags'][flag_name] is None):
-      raise AttributeError('Flag --%s must be specified.' % flag_name)
-
-  def _assert_all_required(self):
-    for flag_name in self.__dict__['__required_flags']:
-      self._assert_required(flag_name)
-
-
-def _define_helper(flag_name, default_value, docstring, flagtype):
-  """Registers 'flag_name' with 'default_value' and 'docstring'."""
-  _global_parser.add_argument('--' + flag_name,
-                              default=default_value,
-                              help=docstring,
-                              type=flagtype)
-
-
-# Provides the global object that can be used to access flags.
-FLAGS = _FlagValues()
-
-
-def DEFINE_string(flag_name, default_value, docstring):
-  """Defines a flag of type 'string'.
-
-  Args:
-    flag_name: The name of the flag as a string.
-    default_value: The default value the flag should take as a string.
-    docstring: A helpful message explaining the use of the flag.
-  """
-  _define_helper(flag_name, default_value, docstring, str)
-
-
-def DEFINE_integer(flag_name, default_value, docstring):
-  """Defines a flag of type 'int'.
-
-  Args:
-    flag_name: The name of the flag as a string.
-    default_value: The default value the flag should take as an int.
-    docstring: A helpful message explaining the use of the flag.
-  """
-  _define_helper(flag_name, default_value, docstring, int)
-
-
-def DEFINE_boolean(flag_name, default_value, docstring):
-  """Defines a flag of type 'boolean'.
-
-  Args:
-    flag_name: The name of the flag as a string.
-    default_value: The default value the flag should take as a boolean.
-    docstring: A helpful message explaining the use of the flag.
-  """
-  # Register a custom function for 'bool' so --flag=True works.
-  def str2bool(v):
-    return v.lower() in ('true', 't', '1')
-  _global_parser.add_argument('--' + flag_name,
-                              nargs='?',
-                              const=True,
-                              help=docstring,
-                              default=default_value,
-                              type=str2bool)
-
-  # Add negated version, stay consistent with argparse with regard to
-  # dashes in flag names.
-  _global_parser.add_argument('--no' + flag_name,
-                              action='store_false',
-                              dest=flag_name.replace('-', '_'))
-
-
-# The internal google library defines the following alias, so we match
-# the API for consistency.
-DEFINE_bool = DEFINE_boolean  # pylint: disable=invalid-name
-
-
-def DEFINE_float(flag_name, default_value, docstring):
-  """Defines a flag of type 'float'.
-
-  Args:
-    flag_name: The name of the flag as a string.
-    default_value: The default value the flag should take as a float.
-    docstring: A helpful message explaining the use of the flag.
-  """
-  _define_helper(flag_name, default_value, docstring, float)
-
-
-def mark_flag_as_required(flag_name):
-  """Ensures that flag is not None during program execution.
-  
-  It is recommended to call this method like this:
-  
-    if __name__ == '__main__':
-      tf.flags.mark_flag_as_required('your_flag_name')
-      tf.app.run()
-  
-  Args:
-    flag_name: string, name of the flag to mark as required.
- 
-  Raises:
-    AttributeError: if flag_name is not registered as a valid flag name.
-      NOTE: The exception raised will change in the future. 
-  """
-  if _global_parser.get_default(flag_name) is not None:
-    _logging.warn(
-        'Flag %s has a non-None default value; therefore, '
-        'mark_flag_as_required will pass even if flag is not specified in the '
-        'command line!' % flag_name)
-  FLAGS._add_required_flag(flag_name)
-
-
-def mark_flags_as_required(flag_names):
-  """Ensures that flags are not None during program execution.
-  
-  Recommended usage:
-  
-    if __name__ == '__main__':
-      tf.flags.mark_flags_as_required(['flag1', 'flag2', 'flag3'])
-      tf.app.run()
-  
-  Args:
-    flag_names: a list/tuple of flag names to mark as required.
-
-  Raises:
-    AttributeError: If any of flag name has not already been defined as a flag.
-      NOTE: The exception raised will change in the future.
-  """
-  for flag_name in flag_names:
-    mark_flag_as_required(flag_name)
-
-
-_allowed_symbols = [
-    # We rely on gflags documentation.
-    'DEFINE_bool',
-    'DEFINE_boolean',
-    'DEFINE_float',
-    'DEFINE_integer',
-    'DEFINE_string',
-    'FLAGS',
-    'mark_flag_as_required',
-    'mark_flags_as_required',
-]
-remove_undocumented(__name__, _allowed_symbols)
+# go/tf-wildcard-import
+from absl.flags import *  # pylint: disable=wildcard-import
diff --git a/tensorflow/python/platform/flags_test.py b/tensorflow/python/platform/flags_test.py
index 7b08c3f8a6da4598e40edd86b479caa6cf190fe9..23060e17d279cfb282f20610e0a1639db3a43ecf 100644
--- a/tensorflow/python/platform/flags_test.py
+++ b/tensorflow/python/platform/flags_test.py
@@ -12,108 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Tests for our flags implementation."""
+"""Sanity tests for tf.flags."""
 from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
-import copy
-import sys
 import unittest
 
-from tensorflow.python.platform import app
-from tensorflow.python.platform import flags
-
-flags.DEFINE_string("string_foo", "default_val", "HelpString")
-flags.DEFINE_integer("int_foo", 42, "HelpString")
-flags.DEFINE_float("float_foo", 42.0, "HelpString")
+from absl import flags as absl_flags
 
-flags.DEFINE_boolean("bool_foo", True, "HelpString")
-flags.DEFINE_boolean("bool_negation", True, "HelpString")
-flags.DEFINE_boolean("bool-dash-negation", True, "HelpString")
-flags.DEFINE_boolean("bool_a", False, "HelpString")
-flags.DEFINE_boolean("bool_c", False, "HelpString")
-flags.DEFINE_boolean("bool_d", True, "HelpString")
-flags.DEFINE_bool("bool_e", True, "HelpString")
-flags.DEFINE_string("string_foo_required", "default_val", "HelpString")
-flags.DEFINE_string("none_string_foo_required", None, "HelpString")
-
-FLAGS = flags.FLAGS
+from tensorflow.python.platform import flags
 
 
 class FlagsTest(unittest.TestCase):
 
-  def testString(self):
-    res = FLAGS.string_foo
-    self.assertEqual(res, "default_val")
-    FLAGS.string_foo = "bar"
-    self.assertEqual("bar", FLAGS.string_foo)
-
-  def testBool(self):
-    res = FLAGS.bool_foo
-    self.assertTrue(res)
-    FLAGS.bool_foo = False
-    self.assertFalse(FLAGS.bool_foo)
-
-  def testBoolCommandLines(self):
-    # Specified on command line with no args, sets to True,
-    # even if default is False.
-    self.assertEqual(True, FLAGS.bool_a)
-
-    # --no before the flag forces it to False, even if the
-    # default is True
-    self.assertEqual(False, FLAGS.bool_negation)
-
-    # --bool_flag=True sets to True
-    self.assertEqual(True, FLAGS.bool_c)
-
-    # --bool_flag=False sets to False
-    self.assertEqual(False, FLAGS.bool_d)
-
-  def testInt(self):
-    res = FLAGS.int_foo
-    self.assertEquals(res, 42)
-    FLAGS.int_foo = -1
-    self.assertEqual(-1, FLAGS.int_foo)
-
-  def testFloat(self):
-    res = FLAGS.float_foo
-    self.assertEquals(42.0, res)
-    FLAGS.float_foo = -1.0
-    self.assertEqual(-1.0, FLAGS.float_foo)
-
-  def test_copy(self):
-    copied = copy.copy(FLAGS)
-    self.assertEqual(copied.__dict__, FLAGS.__dict__)
-
-  def testStringRequired(self):
-    res = FLAGS.string_foo_required
-    self.assertEqual(res, "default_val")
-    FLAGS.string_foo_required = "bar"
-    self.assertEqual("bar", FLAGS.string_foo_required)
-
-  def testNoneStringRequired(self):
-    res = FLAGS.none_string_foo_required
-    self.assertEqual(res, "default_val")
-    FLAGS.none_string_foo_required = "bar"
-    self.assertEqual("bar", FLAGS.none_string_foo_required)
-
-
-def main(_):
-  # unittest.main() tries to interpret the unknown flags, so use the
-  # direct functions instead.
-  runner = unittest.TextTestRunner()
-  itersuite = unittest.TestLoader().loadTestsFromTestCase(FlagsTest)
-  runner.run(itersuite)
+  def test_global_flags_object(self):
+    self.assertIs(flags.FLAGS, absl_flags.FLAGS)
 
 
 if __name__ == "__main__":
-  # Test command lines
-  sys.argv.extend([
-      "--bool_a", "--nobool_negation", "--bool_c=True", "--bool_d=False",
-      "--none_string_foo_required=default_val",
-      "and_argument"
-  ])
-  flags.mark_flag_as_required('string_foo_required')
-  flags.mark_flags_as_required(['none_string_foo_required'])
-  app.run()
+  unittest.main()
diff --git a/tensorflow/python/tools/BUILD b/tensorflow/python/tools/BUILD
index 50bffd1474cca0a5f0fbd3f3a19a62440ad574d1..69586c6a47762701344aafe449e96868875f8926 100644
--- a/tensorflow/python/tools/BUILD
+++ b/tensorflow/python/tools/BUILD
@@ -151,7 +151,6 @@ py_library(
     srcs = ["optimize_for_inference_lib.py"],
     srcs_version = "PY2AND3",
     deps = [
-        ":strip_unused",
         ":strip_unused_lib",
         "//tensorflow/core:protos_all_py",
         "//tensorflow/python:framework",
diff --git a/tensorflow/python/tools/import_pb_to_tensorboard.py b/tensorflow/python/tools/import_pb_to_tensorboard.py
old mode 100644
new mode 100755
diff --git a/tensorflow/python/training/checkpoint_ops.py b/tensorflow/python/training/checkpoint_ops.py
index 0769ccd3d143122b9948138538a815ae09b60dff..7f92d94d2be369709608d36c109863b0ebfb7bbe 100644
--- a/tensorflow/python/training/checkpoint_ops.py
+++ b/tensorflow/python/training/checkpoint_ops.py
@@ -36,6 +36,7 @@ def _load_and_remap_matrix(ckpt_path,
                            num_rows_to_load,
                            new_col_vocab_size,
                            initializer,
+                           old_row_vocab_size=-1,
                            old_row_vocab_file=None,
                            new_row_vocab_file=None,
                            old_col_vocab_file=None,
@@ -75,6 +76,12 @@ def _load_and_remap_matrix(ckpt_path,
     initializer: Callable initializer function that accepts a 1-D tensor as the
       arg to specify the shape of the returned tensor. Used to initialize
       missing values.
+    old_row_vocab_size: The number of entries to consider in the old vocabulary.
+      With the default value of -1, the entire old row vocabulary file will be
+      used.  Otherwise, only the first `old_row_vocab_size` entries will be
+      considered for remapping.Must be smaller than the length of
+      `old_row_vocab_file`.  NOTE: we do not provide an equivalent
+      `old_col_vocab_size` for classes.
     old_row_vocab_file: A scalar `Tensor` of type `string` containing the
       path to the old row vocabulary file. Can be None, which represents no
       remapping on the row axis.
@@ -146,7 +153,8 @@ def _load_and_remap_matrix(ckpt_path,
             new_vocab_file=new_row_vocab_file,
             old_vocab_file=old_row_vocab_file,
             new_vocab_offset=new_row_vocab_offset,
-            num_new_vocab=num_rows_to_load))
+            num_new_vocab=num_rows_to_load,
+            old_vocab_size=old_row_vocab_size))
   else:
     # Even when the rows are not being reordered, we still need to generate a
     # remapping to account for initializing partitioned Variables (when
@@ -199,6 +207,7 @@ def _load_and_remap_matrix_initializer(ckpt_path,
                                        old_tensor_name,
                                        new_row_vocab_size,
                                        new_col_vocab_size,
+                                       old_row_vocab_size=-1,
                                        old_row_vocab_file=None,
                                        new_row_vocab_file=None,
                                        old_col_vocab_file=None,
@@ -280,6 +289,12 @@ def _load_and_remap_matrix_initializer(ckpt_path,
       `new_col_vocab_file`. If no column remapping is needed (no column vocab
       provided), this should be equal to the number of columns in the old
       matrix.
+    old_row_vocab_size: The number of entries to consider in the old vocabulary.
+      With the default value of -1, the entire old row vocabulary file will be
+      used.  Otherwise, only the first `old_row_vocab_size` entries will be
+      considered for remapping.Must be smaller than the length of
+      `old_row_vocab_file`.  NOTE: we do not provide an equivalent
+      `old_col_vocab_size` for classes.
     old_row_vocab_file: A scalar `Tensor` of type `string` containing the
       path to the old row vocabulary file. Can be None, which represents no
       remapping on the row axis.
@@ -388,6 +403,7 @@ def _load_and_remap_matrix_initializer(ckpt_path,
         num_rows_to_load=num_rows_to_load,
         new_col_vocab_size=new_col_vocab_size,
         initializer=initializer,
+        old_row_vocab_size=old_row_vocab_size,
         old_row_vocab_file=old_row_vocab_file,
         new_row_vocab_file=new_row_vocab_file,
         old_col_vocab_file=old_col_vocab_file,
@@ -405,6 +421,7 @@ def _load_embedding_initializer(ckpt_path,
                                 embedding_dim,
                                 old_vocab_file,
                                 new_vocab_file,
+                                old_vocab_size=-1,
                                 num_oov_buckets=0,
                                 initializer=None,
                                 max_rows_in_memory=-1):
@@ -428,6 +445,11 @@ def _load_embedding_initializer(ckpt_path,
       path to the old vocabulary file.
     new_vocab_file: A scalar `Tensor` of type `string` containing the
       path to the new vocabulary file.
+    old_vocab_size: The number of entries to consider in the old vocabulary.
+      With the default value of -1, the entire old row vocabulary file will be
+      used.  Otherwise, only the first `old_vocab_size` entries will be
+      considered for remapping.Must be smaller than the length of
+      `old_row_vocab_file`.
     num_oov_buckets: `int` specifying the number of out-of-vocabulary
       buckets to use. Must be >= 0.
     initializer: Initializer function that accepts a 1-D tensor as the arg to
@@ -452,6 +474,7 @@ def _load_embedding_initializer(ckpt_path,
       old_tensor_name=embedding_tensor_name,
       new_row_vocab_size=new_vocab_size,
       new_col_vocab_size=embedding_dim,
+      old_row_vocab_size=old_vocab_size,
       old_row_vocab_file=old_vocab_file,
       new_row_vocab_file=new_vocab_file,
       old_col_vocab_file=None,
diff --git a/tensorflow/python/training/checkpoint_ops_test.py b/tensorflow/python/training/checkpoint_ops_test.py
index b578dde25171d88e89eee1285507bb432c0b7d62..00611de862752dd7e69d867fcb50bb3e21f0ae1b 100644
--- a/tensorflow/python/training/checkpoint_ops_test.py
+++ b/tensorflow/python/training/checkpoint_ops_test.py
@@ -103,7 +103,7 @@ class LoadAndRemapWrappersTest(test.TestCase):
         num_col_oov_buckets=1)
 
     # [4 in vocab + 1 oov features, 4 in vocab + 1 oov classes].  The offset
-    # means we read
+    # means we read from the first line.
     expected_remapped_matrix = np.concatenate(
         [
             np.reshape([18, 34, 50, self.init_val, self.init_val], [5, 1]),
@@ -132,6 +132,9 @@ class LoadAndRemapWrappersTest(test.TestCase):
         num_col_oov_buckets=1,
         initializer=self.initializer))
 
+    # The new weight matrix is of size
+    # [5 feature vocab + 1 feature OOV, 4 class vocab + 1 class OOV].  Use a
+    # partitioned variable to confirm that the offset logic works.
     expected_remapped_matrix = np.concatenate(
         [
             np.reshape([2, 18, 34, 50, self.init_val, self.init_val], [6, 1]),
@@ -141,10 +144,6 @@ class LoadAndRemapWrappersTest(test.TestCase):
             np.reshape([self.init_val] * 6, [6, 1])
         ],
         axis=1)
-
-    # The new weight matrix is of size
-    # [5 feature vocab + 1 feature OOV, 4 class vocab + 1 class OOV].  Use a
-    # partitioned variable to confirm that the offset logic works.
     remapped_matrix = variable_scope.get_variable(
         name='linear/obtained_weight_matrix',
         shape=[6, 5],
@@ -168,6 +167,8 @@ class LoadAndRemapWrappersTest(test.TestCase):
         num_col_oov_buckets=1,
         initializer=self.initializer))
 
+    # The new weight matrix is of size
+    # [5-sized input layer, 4 class vocab + 1 class OOV].
     expected_remapped_matrix = np.concatenate(
         [
             np.reshape([2, 18, 34, 50, 66], [5, 1]),
@@ -177,9 +178,6 @@ class LoadAndRemapWrappersTest(test.TestCase):
             np.reshape([self.init_val] * 5, [5, 1])
         ],
         axis=1)
-
-    # The new weight matrix is of size
-    # [5-sized input layer, 4 class vocab + 1 class OOV].
     remapped_matrix = variable_scope.get_variable(
         name='dnn_output/obtained_weight_matrix',
         shape=[5, 5],
@@ -206,6 +204,9 @@ class LoadAndRemapWrappersTest(test.TestCase):
         num_col_oov_buckets=1,
         initializer=self.initializer))
 
+    # The new weight matrix is of size
+    # [5 feature vocab + 5 feature OOV, 4 class vocab + 1 class OOV].  The
+    # second partition has only OOV.
     expected_remapped_matrix = np.concatenate(
         [
             np.reshape([2, 18, 34, 50] + [self.init_val] * 6, [10, 1]),
@@ -215,10 +216,6 @@ class LoadAndRemapWrappersTest(test.TestCase):
             np.reshape([self.init_val] * 10, [10, 1]),
         ],
         axis=1)
-
-    # The new weight matrix is of size
-    # [5 feature vocab + 5 feature OOV, 4 class vocab + 1 class OOV].  The
-    # second partition has only OOV.
     remapped_matrix = variable_scope.get_variable(
         name='linear_all_oov/obtained_weight_matrix',
         shape=[10, 5],
@@ -244,6 +241,8 @@ class LoadAndRemapWrappersTest(test.TestCase):
         num_row_oov_buckets=1,
         num_col_oov_buckets=1))
 
+    # Same as test_initializer_with_oov_only_partition, but with zero
+    # initialization.
     expected_remapped_matrix = np.concatenate(
         [
             np.reshape([2, 18, 34, 50, 0, 0], [6, 1]),
@@ -253,7 +252,6 @@ class LoadAndRemapWrappersTest(test.TestCase):
             np.reshape([0] * 6, [6, 1])
         ],
         axis=1)
-
     remapped_matrix = variable_scope.get_variable(
         name='linear_init_fallback/obtained_weight_matrix',
         shape=[6, 5],
@@ -277,18 +275,17 @@ class LoadAndRemapWrappersTest(test.TestCase):
         num_oov_buckets=1,
         initializer=self.initializer))
 
+    # The new weight matrix is of size
+    # [5 feature vocab + 1 feature OOV, 16 (embedding dimension)], where the
+    # last vocab row (2nd last row) is newly initialized (wasn't found in
+    # previous vocab) and the actual last row is OOV and also newly initialized.
+    # Use a partitioned variable to confirm that the offset logic works.
     expected_remapped_embeddings = np.concatenate(
         [
             np.reshape(range(64), [4, 16]),
             np.reshape([self.init_val] * 32, [2, 16]),
         ],
         axis=0)
-
-    # The new weight matrix is of size
-    # [5 feature vocab + 1 feature OOV, 16 (embedding dimension)], where the
-    # last vocab row (2nd last row) is newly initialized (wasn't found in
-    # previous vocab) and the actual last row is OOV and also newly initialized.
-    # Use a partitioned variable to confirm that the offset logic works.
     remapped_embeddings = variable_scope.get_variable(
         name='embedding/obtained_embedding_matrix',
         shape=[6, 16],
@@ -323,6 +320,11 @@ class LoadAndRemapWrappersTest(test.TestCase):
         num_oov_buckets=5,
         initializer=self.initializer))
 
+    # The new weight matrix is of size
+    # [4 feature vocab + 5 feature OOV, 16 (embedding dimension)], where the
+    # 3rd and 4th rows are not found in the old vocabulary and therefore newly
+    # initialized.  The last five rows are OOV and also newly initialized.
+    # Use a partitioned variable to confirm that the offset logic works.
     expected_remapped_embeddings = np.concatenate(
         [
             np.reshape(range(16, 32), [1, 16]),
@@ -330,15 +332,47 @@ class LoadAndRemapWrappersTest(test.TestCase):
             np.reshape([self.init_val] * 112, [7, 16]),
         ],
         axis=0)
+    remapped_embeddings = variable_scope.get_variable(
+        name='embedding/obtained_embedding_matrix',
+        shape=[9, 16],
+        initializer=embedding_loading_initializer,
+        partitioner=partitioned_variables.fixed_size_partitioner(2))
+
+    with self.test_session():
+      variables.global_variables_initializer().run()
+      self.assertAllClose(expected_remapped_embeddings,
+                          remapped_embeddings.as_tensor().eval())
+
+  def test_load_embedding_initializer_old_row_vocab(self):
+    """Tests for load_embedding_initializer where we constrain old vocab."""
+    embedding_loading_initializer = (
+        checkpoint_ops._load_embedding_initializer(
+            new_vocab_file=self.new_feature_vocab_file,
+            old_vocab_file=self.old_feature_vocab_file,
+            # Considered old vocabulary becomes ['zero', 'one', 'two'].  This
+            # means 'three' in the new vocabulary is newly initialized.
+            old_vocab_size=3,
+            new_vocab_size=5,
+            embedding_dim=16,
+            embedding_tensor_name='some_scope/embeddings',
+            ckpt_path=[self.checkpoint_file],
+            num_oov_buckets=1,
+            initializer=self.initializer))
 
     # The new weight matrix is of size
-    # [4 feature vocab + 5 feature OOV, 16 (embedding dimension)], where the
-    # 3rd and 4th rows are not found in the old vocabulary and therefore newly
-    # initialized.  The last five rows are OOV and also newly initialized.
+    # [5 feature vocab + 1 feature OOV, 16 (embedding dimension)], where the
+    # last vocab row (2nd last row) is newly initialized (wasn't found in
+    # previous vocab) and the actual last row is OOV and also newly initialized.
     # Use a partitioned variable to confirm that the offset logic works.
+    expected_remapped_embeddings = np.concatenate(
+        [
+            np.reshape(range(48), [3, 16]),
+            np.reshape([self.init_val] * 48, [3, 16]),
+        ],
+        axis=0)
     remapped_embeddings = variable_scope.get_variable(
         name='embedding/obtained_embedding_matrix',
-        shape=[9, 16],
+        shape=[6, 16],
         initializer=embedding_loading_initializer,
         partitioner=partitioned_variables.fixed_size_partitioner(2))
 
@@ -347,6 +381,5 @@ class LoadAndRemapWrappersTest(test.TestCase):
       self.assertAllClose(expected_remapped_embeddings,
                           remapped_embeddings.as_tensor().eval())
 
-
 if __name__ == '__main__':
   test.main()
diff --git a/tensorflow/python/training/moving_averages.py b/tensorflow/python/training/moving_averages.py
index eb073438506691ae4ebe8abf66ca6515e4c56e9f..e34c759e894c86a103f0228163f7bae2ffc7fb61 100644
--- a/tensorflow/python/training/moving_averages.py
+++ b/tensorflow/python/training/moving_averages.py
@@ -498,8 +498,9 @@ class ExponentialMovingAverage(object):
     # Collect all the variables with moving average,
     for v in moving_avg_variables:
       name_map[self.average_name(v)] = v
-    # Make sure we restore variables without moving average as well.
-    for v in list(set(variables.global_variables()) - moving_avg_variables):
-      if v.op.name not in name_map:
+    # Make sure we restore variables without moving averages as well.
+    moving_avg_variable_names = set([v.name for v in moving_avg_variables])
+    for v in list(set(variables.global_variables())):
+      if v.name not in moving_avg_variable_names and v.op.name not in name_map:
         name_map[v.op.name] = v
     return name_map
diff --git a/tensorflow/python/training/moving_averages_test.py b/tensorflow/python/training/moving_averages_test.py
index 63604cf19d4e73370dd705ac8c117d4f2097f415..6efdeb286657e761a4c46634b9408121765a447b 100644
--- a/tensorflow/python/training/moving_averages_test.py
+++ b/tensorflow/python/training/moving_averages_test.py
@@ -27,6 +27,7 @@ from tensorflow.python.ops import variable_scope
 from tensorflow.python.ops import variables
 from tensorflow.python.platform import test
 from tensorflow.python.training import moving_averages
+from tensorflow.python.training import saver as saver_lib
 
 
 class MovingAveragesTest(test.TestCase):
@@ -392,6 +393,32 @@ class ExponentialMovingAverageTest(test.TestCase):
     self.assertEqual([b"loc:@v1"], ema.average(v1).op.colocation_groups())
     self.assertDeviceEqual("/job:default", ema.average(tensor2).device)
 
+  def _ExportAndImportGraph(self, graph):
+    """Export and import graph into a new graph."""
+    meta_graph = saver_lib.export_meta_graph(
+        graph=graph, collection_list=graph.get_all_collection_keys())
+    graph_copy = ops.Graph()
+    with graph_copy.as_default():
+      _ = saver_lib.import_meta_graph(meta_graph)
+    return graph_copy
+
+  def testImportedGraphVariablesToRestore(self):
+    g = ops.Graph()
+    with g.as_default():
+      variables.Variable(10.0, name="v")
+    # Export and import the graph into a new graph.
+    g_copy = self._ExportAndImportGraph(g)
+    with g_copy.as_default():
+      ema = moving_averages.ExponentialMovingAverage(0.25, name="foo_avg")
+      vars_to_restore = ema.variables_to_restore()
+      # There should only be one variable in vars_to_restore. This is important
+      # to check because when importing from a GraphDef, TF makes duplicate
+      # python Variable objects referring to the same underlying variable. We
+      # need to be sure that two variables referring to the same variable don't
+      # both get added to vars_to_restore.
+      self.assertEqual(len(vars_to_restore), 1)
+      self.assertTrue("v/foo_avg" in vars_to_restore)
+
 
 if __name__ == "__main__":
   test.main()
diff --git a/tensorflow/python/util/tf_should_use.py b/tensorflow/python/util/tf_should_use.py
index 99081cb29470900992f4583445817521e8dd2553..a576547d5f2ad98ebe73432d8cf4ff14d3921733 100644
--- a/tensorflow/python/util/tf_should_use.py
+++ b/tensorflow/python/util/tf_should_use.py
@@ -22,6 +22,7 @@ import types
 
 import six  # pylint: disable=unused-import
 
+from tensorflow.python.eager import context
 from tensorflow.python.util import tf_decorator
 # pylint: enable=g-bad-import-order,g-import-not-at-top
 
@@ -31,6 +32,8 @@ from tensorflow.python.util import tf_decorator
 def _add_should_use_warning(x, fatal_error=False):
   """Wraps object x so that if it is never used, a warning is logged.
 
+  Does nothing when executing eagerly.
+
   Args:
     x: Python object.
     fatal_error: Python bool.  If `True`, tf.logging.fatal is raised
@@ -44,9 +47,10 @@ def _add_should_use_warning(x, fatal_error=False):
   if x is None:  # special corner case where x is None
     return x
 
-  # TODO(apassos) we don't have an easier way to check because importing context
-  # or ops here would create a BUILD dependency cycle.
-  if type(x).__name__ == 'EagerTensor':
+  if context.in_eager_mode():
+    # Typically not needed when executing eagerly (the main use case is for ops
+    # which need to be incorporated into the graph), and even the no-op wrapper
+    # creates reference cycles which require garbage collection.
     return x
 
   def override_method(method):
@@ -102,6 +106,8 @@ def should_use_result(fn):
   - `t != 0`.  In this case, comparison is done on types / ids.
   - `isinstance(t, tf.Tensor)`.  Similar to above.
 
+  Does nothing when executing eagerly.
+
   Args:
     fn: The function to wrap.
 
@@ -136,6 +142,8 @@ def must_use_result_or_fatal(fn):
   - `t != 0`.  In this case, comparison is done on types / ids.
   - `isinstance(t, tf.Tensor)`.  Similar to above.
 
+  Does nothing when executing eagerly.
+
   Args:
     fn: The function to wrap.
 
diff --git a/tensorflow/stream_executor/cuda/cuda_gpu_executor.cc b/tensorflow/stream_executor/cuda/cuda_gpu_executor.cc
index 5679598cf3a829e769fffef22e3ad0ef2faa65f9..6c522264e1de2b3c141eeb7c46b77c10a2f4335f 100644
--- a/tensorflow/stream_executor/cuda/cuda_gpu_executor.cc
+++ b/tensorflow/stream_executor/cuda/cuda_gpu_executor.cc
@@ -123,12 +123,8 @@ CUDAExecutor *ExtractCudaExecutor(StreamExecutor *stream_exec) {
 }
 
 CUDAExecutor::~CUDAExecutor() {
-  for (auto &it : disk_modules_) {
-    CUDADriver::UnloadModule(context_, it.second);
-  }
-  for (auto &it : in_memory_modules_) {
-    CUDADriver::UnloadModule(context_, it.second);
-  }
+  CHECK(kernel_to_gpu_binary_.empty()) << "CUDAExecutor has live kernels.";
+  CHECK(gpu_binary_to_module_.empty()) << "CUDAExecutor has loaded modules.";
   if (context_ != nullptr) {
     CUDADriver::DestroyContext(context_);
   }
@@ -219,26 +215,17 @@ static string GetBinaryDir(bool strip_exe) {
 bool CUDAExecutor::GetKernel(const MultiKernelLoaderSpec &spec,
                              KernelBase *kernel) {
   CUDAKernel *cuda_kernel = AsCUDAKernel(kernel);
-  CUmodule module = nullptr;
+  CUmodule module;
   const string *kernelname;
 
-  const OnDiskKernelLoaderSpec *on_disk_spec = nullptr;
-  bool has_ptx = spec.has_cuda_ptx_on_disk();
-  bool has_cubin = spec.has_cuda_cubin_on_disk();
-  if (has_cubin && (!has_ptx || FLAGS_prefer_cubin_to_ptx)) {
-    on_disk_spec = &spec.cuda_cubin_on_disk();
-  } else if (has_ptx) {
-    on_disk_spec = &spec.cuda_ptx_on_disk();
-  }
+  VLOG(3) << "GetKernel on kernel " << kernel << " : " << kernel->name();
 
-  if (on_disk_spec != nullptr) {
-    LOG(WARNING) << "loading CUDA kernel from disk is not supported";
-    return false;
-  } else if (spec.has_cuda_cubin_in_memory()) {
+  if (spec.has_cuda_cubin_in_memory()) {
     kernelname = &spec.cuda_cubin_in_memory().kernelname();
     const char *cubin = spec.cuda_cubin_in_memory().bytes();
     mutex_lock lock{in_memory_modules_mu_};
-    module = in_memory_modules_[cubin];
+    uint64_t module_refcount;
+    std::tie(module, module_refcount) = gpu_binary_to_module_[cubin];
 
     if (module == nullptr) {
       auto load_status = CUDADriver::LoadCubin(context_, cubin, &module);
@@ -246,9 +233,16 @@ bool CUDAExecutor::GetKernel(const MultiKernelLoaderSpec &spec,
         LOG(ERROR) << "failed to load CUBIN: " << load_status;
         return false;
       }
-
-      in_memory_modules_[cubin] = module;
+      module_refcount = 1;
+      VLOG(3) << "Loaded CUBIN " << static_cast<const void *>(cubin)
+              << " as module " << module;
+    } else {
+      ++module_refcount;
+      VLOG(3) << "CUBIN " << static_cast<const void *>(cubin)
+              << " is already loaded as module " << module;
     }
+    kernel_to_gpu_binary_[kernel] = cubin;
+    gpu_binary_to_module_[cubin] = {module, module_refcount};
   } else if (spec.has_cuda_ptx_in_memory()) {
     kernelname = &spec.cuda_ptx_in_memory().kernelname();
 
@@ -256,47 +250,39 @@ bool CUDAExecutor::GetKernel(const MultiKernelLoaderSpec &spec,
       return false;
     }
 
-    // Note that the orignal ptx may be compressed, and the ptx we get below is
-    // the decompressed result. To cache the module we should use the original
-    // ptx (compressed one) as the key. This is because for the same compressed
-    // ptx, we may get different decompressed ptx wrt the pointer value.
     const char *ptx = spec.cuda_ptx_in_memory().text(cc_major_, cc_minor_);
-    const char *orig_ptx =
-        spec.cuda_ptx_in_memory().original_text(cc_major_, cc_minor_);
-    if (ptx == nullptr || orig_ptx == nullptr) {
+    if (ptx == nullptr) {
       ptx = spec.cuda_ptx_in_memory().default_text();
-      orig_ptx = spec.cuda_ptx_in_memory().original_default_text();
     }
-    if (ptx == nullptr || orig_ptx == nullptr) {
-      LOG(FATAL) << "could not load ptx for kernel " << kernelname;
+    if (ptx == nullptr) {
+      LOG(FATAL) << "loader spec has no ptx for kernel " << *kernelname;
       return false;
     }
 
     mutex_lock lock{in_memory_modules_mu_};
-    module = in_memory_modules_[orig_ptx];
+    uint64_t module_refcount;
+    std::tie(module, module_refcount) = gpu_binary_to_module_[ptx];
 
     if (module == nullptr) {
-      if (g_cubinate == nullptr) {
-        if (!CUDADriver::LoadPtx(context_, ptx, &module)) {
-          return false;
-        }
-      } else {
-        string cubin = g_cubinate(ptx);
-        auto load_status =
-            CUDADriver::LoadCubin(context_, cubin.c_str(), &module);
-        if (!load_status.ok()) {
-          LOG(ERROR) << "failed to load cubin via hook: " << load_status;
-          return false;
-        }
+      if (!CUDADriver::LoadPtx(context_, ptx, &module)) {
+        LOG(ERROR) << "failed to load PTX for kernel " << *kernelname;
+        return false;
       }
-      in_memory_modules_[orig_ptx] = module;
+      VLOG(3) << "Loaded PTX " << static_cast<const void *>(ptx)
+              << " as module " << module;
+      module_refcount = 1;
+    } else {
+      ++module_refcount;
+      VLOG(3) << "PTX " << static_cast<const void *>(ptx)
+              << " is already loaded as module " << module;
     }
+    kernel_to_gpu_binary_[kernel] = ptx;
+    gpu_binary_to_module_[ptx] = {module, module_refcount};
   } else {
     LOG(WARNING) << "no method of loading CUDA kernel provided";
     return false;
   }
-
-  VLOG(2) << "getting function " << kernelname << " from module " << module;
+  VLOG(2) << "getting function " << *kernelname << " from module " << module;
   if (!CUDADriver::GetModuleFunction(context_, module, kernelname->c_str(),
                                      cuda_kernel->cuda_function_ptr())) {
     return false;
@@ -308,13 +294,44 @@ bool CUDAExecutor::GetKernel(const MultiKernelLoaderSpec &spec,
 
   KernelMetadata kernel_metadata;
   if (!GetKernelMetadata(cuda_kernel, &kernel_metadata)) {
-    LOG(WARNING) << "Unable to get metadata for kernel " << kernelname;
+    LOG(WARNING) << "unable to get metadata for kernel " << *kernelname;
   }
   kernel->set_metadata(kernel_metadata);
   kernel->set_name(*kernelname);
   return true;
 }
 
+void CUDAExecutor::UnloadKernel(const KernelBase *kernel) {
+  VLOG(3) << "Unloading kernel " << kernel << " : " << kernel->name();
+
+  mutex_lock lock{in_memory_modules_mu_};
+  auto gpu_binary_it = kernel_to_gpu_binary_.find(kernel);
+  if (kernel_to_gpu_binary_.end() == gpu_binary_it) {
+    VLOG(3) << "Kernel " << kernel << " : " << kernel->name()
+            << " has never been loaded.";
+    return;  // We've never seen this kernel.
+  }
+  VLOG(3) << "Kernel " << kernel << " : " << kernel->name()
+          << " has loaded GPU code " << gpu_binary_it->second;
+  auto module_it = gpu_binary_to_module_.find(gpu_binary_it->second);
+  if (gpu_binary_to_module_.end() == module_it) {
+    VLOG(3) << "Kernel " << kernel << " : " << kernel->name()
+            << " has no loaded CUDA module.";
+    return;  // This kernel never loaded any modules
+  }
+  auto &module = module_it->second.first;
+  auto &refcount = module_it->second.second;
+  VLOG(3) << "Kernel " << kernel << " : " << kernel->name()
+          << " has loaded GPU code " << gpu_binary_it->second
+          << " into CUDA module " << module << " with refcount " << refcount;
+  if (--refcount == 0) {
+    VLOG(3) << "Unloading CUDA module " << module;
+    CUDADriver::UnloadModule(context_, module);
+    gpu_binary_to_module_.erase(module_it);
+  }
+  kernel_to_gpu_binary_.erase(gpu_binary_it);
+}
+
 bool CUDAExecutor::GetKernelMetadata(CUDAKernel *cuda_kernel,
                                      KernelMetadata *kernel_metadata) {
   int value;
@@ -774,21 +791,12 @@ bool CUDAExecutor::DeviceMemoryUsage(int64 *free, int64 *total) const {
 
 bool CUDAExecutor::GetSymbol(const string& symbol_name, void **mem,
                              size_t *bytes) {
-  {  // give limited scope to mutex_lock
-    mutex_lock lock{disk_modules_mu_};
-    for (auto &it : disk_modules_) {
-      if (CUDADriver::GetModuleSymbol(context_, it.second, symbol_name.c_str(),
-                                      reinterpret_cast<CUdeviceptr *>(mem),
-                                      bytes)) {
-        return true;
-      }
-    }
-  }
-
   {  // give limited scope to mutex_lock
     mutex_lock lock{in_memory_modules_mu_};
-    for (auto &it : in_memory_modules_) {
-      if (CUDADriver::GetModuleSymbol(context_, it.second, symbol_name.c_str(),
+    for (auto &it : gpu_binary_to_module_) {
+      CUmodule module = it.second.first;
+      CHECK(module != nullptr);
+      if (CUDADriver::GetModuleSymbol(context_, module, symbol_name.c_str(),
                                       reinterpret_cast<CUdeviceptr *>(mem),
                                       bytes)) {
         return true;
diff --git a/tensorflow/stream_executor/cuda/cuda_gpu_executor.h b/tensorflow/stream_executor/cuda/cuda_gpu_executor.h
index 6c5b9dca90b8be632d084aff46657132807b8ea5..8ff4a30d6251dfe4cbbbf1a9c632b6383e964436 100644
--- a/tensorflow/stream_executor/cuda/cuda_gpu_executor.h
+++ b/tensorflow/stream_executor/cuda/cuda_gpu_executor.h
@@ -22,8 +22,8 @@ limitations under the License.
 #ifndef TENSORFLOW_STREAM_EXECUTOR_CUDA_CUDA_GPU_EXECUTOR_H_
 #define TENSORFLOW_STREAM_EXECUTOR_CUDA_CUDA_GPU_EXECUTOR_H_
 
-#include <map>
 #include <set>
+#include <unordered_map>
 
 #include "tensorflow/stream_executor/cuda/cuda_kernel.h"
 #include "tensorflow/stream_executor/event.h"
@@ -62,6 +62,7 @@ class CUDAExecutor : public internal::StreamExecutorInterface {
 
   bool GetKernel(const MultiKernelLoaderSpec &spec,
                  KernelBase *kernel) override;
+  void UnloadKernel(const KernelBase *kernel) override;
 
   bool Launch(Stream *stream, const ThreadDim &thread_dims,
               const BlockDim &block_dims, const KernelBase &k,
@@ -231,19 +232,15 @@ class CUDAExecutor : public internal::StreamExecutorInterface {
   void VlogOccupancyInfo(const KernelBase &kernel, const ThreadDim &thread_dims,
                          const BlockDim &block_dims);
 
-  // Guards the on-disk-module mapping.
-  mutex disk_modules_mu_;
-
-  // Mapping from filename to CUmodule, if it was already retrieved.
-  // Multiple CUfunctions are usually obtained from a single CUmodule so we
-  // attempt to hit in this mapping first, before retrieving it.
-  std::map<string, CUmodule> disk_modules_ GUARDED_BY(disk_modules_mu_);
-
   // Guards the in-memory-module mapping.
   mutex in_memory_modules_mu_;
 
-  std::map<const char *, CUmodule> in_memory_modules_
+  // Kernel -> loaded GPU binary. Many kernels may load the same binary.
+  std::unordered_map<const KernelBase *, const void *> kernel_to_gpu_binary_
       GUARDED_BY(in_memory_modules_mu_);
+  // GPU binary (PTX or CUBIN) -> {CUDA module, reference count}.
+  std::unordered_map<const void *, std::pair<CUmodule, uint64>>
+      gpu_binary_to_module_ GUARDED_BY(in_memory_modules_mu_);
 
   // Guards the launched kernel set.
   mutex launched_kernels_mu_;
diff --git a/tensorflow/stream_executor/kernel.cc b/tensorflow/stream_executor/kernel.cc
index b09fa8aca55576ee338530bff4deba1212eea96b..e1b3635d52eac8c7181395fa76592ae3161a035a 100644
--- a/tensorflow/stream_executor/kernel.cc
+++ b/tensorflow/stream_executor/kernel.cc
@@ -65,7 +65,11 @@ KernelBase::KernelBase(StreamExecutor *parent,
                        internal::KernelInterface *implementation)
     : parent_(parent), implementation_(implementation) {}
 
-KernelBase::~KernelBase() {}
+KernelBase::~KernelBase() {
+  if (parent_) {
+    parent_->UnloadKernel(this);
+  }
+}
 
 unsigned KernelBase::Arity() const { return implementation_->Arity(); }
 
diff --git a/tensorflow/stream_executor/stream_executor_internal.h b/tensorflow/stream_executor/stream_executor_internal.h
index 12593e31d4e67f25136edf541d4bc03f3e72b54b..14445a7657be10a6d3d93ef0aabebcfa17d38b72 100644
--- a/tensorflow/stream_executor/stream_executor_internal.h
+++ b/tensorflow/stream_executor/stream_executor_internal.h
@@ -169,6 +169,8 @@ class StreamExecutorInterface {
                       const KernelArgsArrayBase &args) {
     return false;
   }
+  // Releases any state associated with the kernel.
+  virtual void UnloadKernel(const KernelBase *kernel) {}
   virtual void *Allocate(uint64 size) = 0;
   virtual void *AllocateSubBuffer(DeviceMemoryBase *parent, uint64 offset,
                                   uint64 size) = 0;
diff --git a/tensorflow/stream_executor/stream_executor_pimpl.cc b/tensorflow/stream_executor/stream_executor_pimpl.cc
index 9dc1749327b96ecca0a6801d57ac431eab514857..76afb85068bafb805678a9bc03b55b2efa1523c6 100644
--- a/tensorflow/stream_executor/stream_executor_pimpl.cc
+++ b/tensorflow/stream_executor/stream_executor_pimpl.cc
@@ -217,6 +217,10 @@ bool StreamExecutor::GetKernel(const MultiKernelLoaderSpec &spec,
   return implementation_->GetKernel(spec, kernel);
 }
 
+void StreamExecutor::UnloadKernel(const KernelBase *kernel) {
+  implementation_->UnloadKernel(kernel);
+}
+
 void StreamExecutor::Deallocate(DeviceMemoryBase *mem) {
   VLOG(1) << "Called StreamExecutor::Deallocate(mem=" << mem->opaque()
           << ") mem->size()=" << mem->size() << StackTraceIfVLOG10();
diff --git a/tensorflow/stream_executor/stream_executor_pimpl.h b/tensorflow/stream_executor/stream_executor_pimpl.h
index 9c225e5faea69d972802303668673d69e0697570..66c50d47e95fe4e9bf6df24cd61139630000cefb 100644
--- a/tensorflow/stream_executor/stream_executor_pimpl.h
+++ b/tensorflow/stream_executor/stream_executor_pimpl.h
@@ -104,6 +104,9 @@ class StreamExecutor {
   // platform, false is returned.
   bool GetKernel(const MultiKernelLoaderSpec &spec, KernelBase *kernel);
 
+  // Releases any state associated with the previously loaded kernel.
+  void UnloadKernel(const KernelBase *kernel);
+
   // Synchronously allocates an array on the device of type T with element_count
   // elements.
   template <typename T>
diff --git a/tensorflow/tensorflow.bzl b/tensorflow/tensorflow.bzl
index 915880a3d0baa50df975ce877fc201916d7be390..16c3386e1535bd84214ab8b7154b0975bc3eb79e 100644
--- a/tensorflow/tensorflow.bzl
+++ b/tensorflow/tensorflow.bzl
@@ -672,6 +672,11 @@ def tf_cuda_only_cc_test(name,
       }),
       tags=tags + tf_cuda_tests_tags())
 
+register_extension_info(
+    extension_name="tf_cuda_only_cc_test",
+    label_regex_for_dep="{extension_name}_gpu")
+
+
 # Create a cc_test for each of the tensorflow tests listed in "tests"
 def tf_cc_tests(srcs,
                 deps,
@@ -746,6 +751,11 @@ def tf_java_test(name,
       *args,
       **kwargs)
 
+register_extension_info(
+    extension_name="tf_java_test",
+    label_regex_for_dep="{extension_name}")
+
+
 def _cuda_copts():
   """Gets the appropriate set of copts for (maybe) CUDA compilation.
 
@@ -790,6 +800,10 @@ def tf_gpu_kernel_library(srcs,
       alwayslink=1,
       **kwargs)
 
+register_extension_info(
+    extension_name="tf_gpu_kernel_library",
+    label_regex_for_dep="{extension_name}")
+
 
 def tf_cuda_library(deps=None, cuda_deps=None, copts=None, **kwargs):
   """Generate a cc_library with a conditional set of CUDA dependencies.
@@ -937,6 +951,10 @@ def tf_mkl_kernel_library(name,
           nocopts=nocopts
       ))
 
+register_extension_info(
+    extension_name="tf_mkl_kernel_library",
+    label_regex_for_dep="{extension_name}")
+
 
 # Bazel rules for building swig files.
 def _py_wrap_cc_impl(ctx):
@@ -1505,3 +1523,7 @@ def cc_library_with_android_deps(deps,
                                  **kwargs):
   deps = if_not_android(deps) + if_android(android_deps) + common_deps
   native.cc_library(deps=deps, **kwargs)
+
+register_extension_info(
+    extension_name="cc_library_with_android_deps",
+    label_regex_for_dep="{extension_name}")
diff --git a/tensorflow/tools/api/golden/tensorflow.keras.-model.pbtxt b/tensorflow/tools/api/golden/tensorflow.keras.-model.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..b6f9eea2deaa411ae95bbed4e69a37787522de47
--- /dev/null
+++ b/tensorflow/tools/api/golden/tensorflow.keras.-model.pbtxt
@@ -0,0 +1,269 @@
+path: "tensorflow.keras.Model"
+tf_class {
+  is_instance: "<class \'tensorflow.python.keras._impl.keras.engine.training.Model\'>"
+  is_instance: "<class \'tensorflow.python.keras._impl.keras.engine.topology.Network\'>"
+  is_instance: "<class \'tensorflow.python.layers.base.Network\'>"
+  is_instance: "<class \'tensorflow.python.keras._impl.keras.engine.topology.Layer\'>"
+  is_instance: "<class \'tensorflow.python.layers.base.Layer\'>"
+  is_instance: "<type \'object\'>"
+  member {
+    name: "activity_regularizer"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "dtype"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "graph"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "inbound_nodes"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "input"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "input_mask"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "input_shape"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "input_spec"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "losses"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "name"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "non_trainable_variables"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "non_trainable_weights"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "outbound_nodes"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "output"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "output_mask"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "output_shape"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "scope_name"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "state_updates"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "stateful"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "trainable_variables"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "trainable_weights"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "updates"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "uses_learning_phase"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "variables"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "weights"
+    mtype: "<type \'property\'>"
+  }
+  member_method {
+    name: "__init__"
+    argspec: "args=[\'self\', \'inputs\', \'outputs\', \'name\'], varargs=None, keywords=None, defaults=[\'None\'], "
+  }
+  member_method {
+    name: "add_loss"
+    argspec: "args=[\'self\', \'losses\', \'inputs\'], varargs=None, keywords=None, defaults=[\'None\'], "
+  }
+  member_method {
+    name: "add_update"
+    argspec: "args=[\'self\', \'updates\', \'inputs\'], varargs=None, keywords=None, defaults=[\'None\'], "
+  }
+  member_method {
+    name: "add_variable"
+    argspec: "args=[\'self\', \'name\', \'shape\', \'dtype\', \'initializer\', \'regularizer\', \'trainable\', \'constraint\', \'partitioner\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'True\', \'None\', \'None\'], "
+  }
+  member_method {
+    name: "add_weight"
+    argspec: "args=[\'self\', \'name\', \'shape\', \'dtype\', \'initializer\', \'regularizer\', \'trainable\', \'constraint\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'True\', \'None\'], "
+  }
+  member_method {
+    name: "apply"
+    argspec: "args=[\'self\', \'inputs\'], varargs=args, keywords=kwargs, defaults=None"
+  }
+  member_method {
+    name: "build"
+    argspec: "args=[\'self\', \'_\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "call"
+    argspec: "args=[\'self\', \'inputs\', \'mask\'], varargs=None, keywords=None, defaults=[\'None\'], "
+  }
+  member_method {
+    name: "compile"
+    argspec: "args=[\'self\', \'optimizer\', \'loss\', \'metrics\', \'loss_weights\', \'sample_weight_mode\', \'weighted_metrics\', \'target_tensors\'], varargs=None, keywords=kwargs, defaults=[\'None\', \'None\', \'None\', \'None\', \'None\'], "
+  }
+  member_method {
+    name: "compute_mask"
+    argspec: "args=[\'self\', \'inputs\', \'mask\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "count_params"
+    argspec: "args=[\'self\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "evaluate"
+    argspec: "args=[\'self\', \'x\', \'y\', \'batch_size\', \'verbose\', \'sample_weight\', \'steps\'], varargs=None, keywords=None, defaults=[\'None\', \'1\', \'None\', \'None\'], "
+  }
+  member_method {
+    name: "evaluate_generator"
+    argspec: "args=[\'self\', \'generator\', \'steps\', \'max_queue_size\', \'workers\', \'use_multiprocessing\'], varargs=None, keywords=kwargs, defaults=[\'10\', \'1\', \'False\'], "
+  }
+  member_method {
+    name: "fit"
+    argspec: "args=[\'self\', \'x\', \'y\', \'batch_size\', \'epochs\', \'verbose\', \'callbacks\', \'validation_split\', \'validation_data\', \'shuffle\', \'class_weight\', \'sample_weight\', \'initial_epoch\', \'steps_per_epoch\', \'validation_steps\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'1\', \'1\', \'None\', \'0.0\', \'None\', \'True\', \'None\', \'None\', \'0\', \'None\', \'None\'], "
+  }
+  member_method {
+    name: "fit_generator"
+    argspec: "args=[\'self\', \'generator\', \'steps_per_epoch\', \'epochs\', \'verbose\', \'callbacks\', \'validation_data\', \'validation_steps\', \'class_weight\', \'max_queue_size\', \'workers\', \'use_multiprocessing\', \'shuffle\', \'initial_epoch\'], varargs=None, keywords=kwargs, defaults=[\'1\', \'1\', \'None\', \'None\', \'None\', \'None\', \'10\', \'1\', \'False\', \'True\', \'0\'], "
+  }
+  member_method {
+    name: "from_config"
+    argspec: "args=[\'cls\', \'config\', \'custom_objects\'], varargs=None, keywords=None, defaults=[\'None\'], "
+  }
+  member_method {
+    name: "get_config"
+    argspec: "args=[\'self\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_input_at"
+    argspec: "args=[\'self\', \'node_index\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_input_mask_at"
+    argspec: "args=[\'self\', \'node_index\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_input_shape_at"
+    argspec: "args=[\'self\', \'node_index\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_layer"
+    argspec: "args=[\'self\', \'name\', \'index\'], varargs=None, keywords=None, defaults=[\'None\', \'None\'], "
+  }
+  member_method {
+    name: "get_losses_for"
+    argspec: "args=[\'self\', \'inputs\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_output_at"
+    argspec: "args=[\'self\', \'node_index\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_output_mask_at"
+    argspec: "args=[\'self\', \'node_index\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_output_shape_at"
+    argspec: "args=[\'self\', \'node_index\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_updates_for"
+    argspec: "args=[\'self\', \'inputs\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_weights"
+    argspec: "args=[\'self\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "load_weights"
+    argspec: "args=[\'self\', \'filepath\', \'by_name\'], varargs=None, keywords=None, defaults=[\'False\'], "
+  }
+  member_method {
+    name: "predict"
+    argspec: "args=[\'self\', \'x\', \'batch_size\', \'verbose\', \'steps\'], varargs=None, keywords=None, defaults=[\'None\', \'0\', \'None\'], "
+  }
+  member_method {
+    name: "predict_generator"
+    argspec: "args=[\'self\', \'generator\', \'steps\', \'max_queue_size\', \'workers\', \'use_multiprocessing\', \'verbose\'], varargs=None, keywords=kwargs, defaults=[\'10\', \'1\', \'False\', \'0\'], "
+  }
+  member_method {
+    name: "predict_on_batch"
+    argspec: "args=[\'self\', \'x\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "reset_states"
+    argspec: "args=[\'self\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "save"
+    argspec: "args=[\'self\', \'filepath\', \'overwrite\', \'include_optimizer\'], varargs=None, keywords=None, defaults=[\'True\', \'True\'], "
+  }
+  member_method {
+    name: "save_weights"
+    argspec: "args=[\'self\', \'filepath\', \'overwrite\'], varargs=None, keywords=None, defaults=[\'True\'], "
+  }
+  member_method {
+    name: "set_weights"
+    argspec: "args=[\'self\', \'weights\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "summary"
+    argspec: "args=[\'self\', \'line_length\', \'positions\', \'print_fn\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\'], "
+  }
+  member_method {
+    name: "test_on_batch"
+    argspec: "args=[\'self\', \'x\', \'y\', \'sample_weight\'], varargs=None, keywords=None, defaults=[\'None\'], "
+  }
+  member_method {
+    name: "to_json"
+    argspec: "args=[\'self\'], varargs=None, keywords=kwargs, defaults=None"
+  }
+  member_method {
+    name: "to_yaml"
+    argspec: "args=[\'self\'], varargs=None, keywords=kwargs, defaults=None"
+  }
+  member_method {
+    name: "train_on_batch"
+    argspec: "args=[\'self\', \'x\', \'y\', \'sample_weight\', \'class_weight\'], varargs=None, keywords=None, defaults=[\'None\', \'None\'], "
+  }
+}
diff --git a/tensorflow/tools/api/golden/tensorflow.keras.-sequential.pbtxt b/tensorflow/tools/api/golden/tensorflow.keras.-sequential.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..5076434dbb57eaa158e23a4756778323d58a0399
--- /dev/null
+++ b/tensorflow/tools/api/golden/tensorflow.keras.-sequential.pbtxt
@@ -0,0 +1,294 @@
+path: "tensorflow.keras.Sequential"
+tf_class {
+  is_instance: "<class \'tensorflow.python.keras._impl.keras.models.Sequential\'>"
+  is_instance: "<class \'tensorflow.python.keras._impl.keras.engine.training.Model\'>"
+  is_instance: "<class \'tensorflow.python.keras._impl.keras.engine.topology.Network\'>"
+  is_instance: "<class \'tensorflow.python.layers.base.Network\'>"
+  is_instance: "<class \'tensorflow.python.keras._impl.keras.engine.topology.Layer\'>"
+  is_instance: "<class \'tensorflow.python.layers.base.Layer\'>"
+  is_instance: "<type \'object\'>"
+  member {
+    name: "activity_regularizer"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "dtype"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "graph"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "inbound_nodes"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "input"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "input_mask"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "input_shape"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "input_spec"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "losses"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "name"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "non_trainable_variables"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "non_trainable_weights"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "outbound_nodes"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "output"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "output_mask"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "output_shape"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "regularizers"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "scope_name"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "state_updates"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "stateful"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "trainable"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "trainable_variables"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "trainable_weights"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "updates"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "uses_learning_phase"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "variables"
+    mtype: "<type \'property\'>"
+  }
+  member {
+    name: "weights"
+    mtype: "<type \'property\'>"
+  }
+  member_method {
+    name: "__init__"
+    argspec: "args=[\'self\', \'layers\', \'name\'], varargs=None, keywords=None, defaults=[\'None\', \'None\'], "
+  }
+  member_method {
+    name: "add"
+    argspec: "args=[\'self\', \'layer\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "add_loss"
+    argspec: "args=[\'self\', \'losses\', \'inputs\'], varargs=None, keywords=None, defaults=[\'None\'], "
+  }
+  member_method {
+    name: "add_update"
+    argspec: "args=[\'self\', \'updates\', \'inputs\'], varargs=None, keywords=None, defaults=[\'None\'], "
+  }
+  member_method {
+    name: "add_variable"
+    argspec: "args=[\'self\', \'name\', \'shape\', \'dtype\', \'initializer\', \'regularizer\', \'trainable\', \'constraint\', \'partitioner\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'True\', \'None\', \'None\'], "
+  }
+  member_method {
+    name: "add_weight"
+    argspec: "args=[\'self\', \'name\', \'shape\', \'dtype\', \'initializer\', \'regularizer\', \'trainable\', \'constraint\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'True\', \'None\'], "
+  }
+  member_method {
+    name: "apply"
+    argspec: "args=[\'self\', \'inputs\'], varargs=args, keywords=kwargs, defaults=None"
+  }
+  member_method {
+    name: "build"
+    argspec: "args=[\'self\', \'input_shape\'], varargs=None, keywords=None, defaults=[\'None\'], "
+  }
+  member_method {
+    name: "call"
+    argspec: "args=[\'self\', \'inputs\', \'mask\'], varargs=None, keywords=None, defaults=[\'None\'], "
+  }
+  member_method {
+    name: "compile"
+    argspec: "args=[\'self\', \'optimizer\', \'loss\', \'metrics\', \'sample_weight_mode\', \'weighted_metrics\'], varargs=None, keywords=kwargs, defaults=[\'None\', \'None\', \'None\'], "
+  }
+  member_method {
+    name: "compute_mask"
+    argspec: "args=[\'self\', \'inputs\', \'mask\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "count_params"
+    argspec: "args=[\'self\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "evaluate"
+    argspec: "args=[\'self\', \'x\', \'y\', \'batch_size\', \'verbose\', \'sample_weight\'], varargs=None, keywords=None, defaults=[\'32\', \'1\', \'None\'], "
+  }
+  member_method {
+    name: "evaluate_generator"
+    argspec: "args=[\'self\', \'generator\', \'steps\', \'max_queue_size\', \'workers\', \'use_multiprocessing\'], varargs=None, keywords=kwargs, defaults=[\'10\', \'1\', \'False\'], "
+  }
+  member_method {
+    name: "fit"
+    argspec: "args=[\'self\', \'x\', \'y\', \'batch_size\', \'epochs\', \'verbose\', \'callbacks\', \'validation_split\', \'validation_data\', \'shuffle\', \'class_weight\', \'sample_weight\', \'initial_epoch\'], varargs=None, keywords=None, defaults=[\'32\', \'10\', \'1\', \'None\', \'0.0\', \'None\', \'True\', \'None\', \'None\', \'0\'], "
+  }
+  member_method {
+    name: "fit_generator"
+    argspec: "args=[\'self\', \'generator\', \'steps_per_epoch\', \'epochs\', \'verbose\', \'callbacks\', \'validation_data\', \'validation_steps\', \'class_weight\', \'max_queue_size\', \'workers\', \'use_multiprocessing\', \'initial_epoch\'], varargs=None, keywords=kwargs, defaults=[\'1\', \'1\', \'None\', \'None\', \'None\', \'None\', \'10\', \'1\', \'False\', \'0\'], "
+  }
+  member_method {
+    name: "from_config"
+    argspec: "args=[\'cls\', \'config\', \'custom_objects\'], varargs=None, keywords=None, defaults=[\'None\'], "
+  }
+  member_method {
+    name: "get_config"
+    argspec: "args=[\'self\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_input_at"
+    argspec: "args=[\'self\', \'node_index\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_input_mask_at"
+    argspec: "args=[\'self\', \'node_index\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_input_shape_at"
+    argspec: "args=[\'self\', \'node_index\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_layer"
+    argspec: "args=[\'self\', \'name\', \'index\'], varargs=None, keywords=None, defaults=[\'None\', \'None\'], "
+  }
+  member_method {
+    name: "get_losses_for"
+    argspec: "args=[\'self\', \'inputs\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_output_at"
+    argspec: "args=[\'self\', \'node_index\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_output_mask_at"
+    argspec: "args=[\'self\', \'node_index\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_output_shape_at"
+    argspec: "args=[\'self\', \'node_index\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_updates_for"
+    argspec: "args=[\'self\', \'inputs\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "get_weights"
+    argspec: "args=[\'self\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "load_weights"
+    argspec: "args=[\'self\', \'filepath\', \'by_name\'], varargs=None, keywords=None, defaults=[\'False\'], "
+  }
+  member_method {
+    name: "pop"
+    argspec: "args=[\'self\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "predict"
+    argspec: "args=[\'self\', \'x\', \'batch_size\', \'verbose\'], varargs=None, keywords=None, defaults=[\'32\', \'0\'], "
+  }
+  member_method {
+    name: "predict_classes"
+    argspec: "args=[\'self\', \'x\', \'batch_size\', \'verbose\'], varargs=None, keywords=None, defaults=[\'32\', \'1\'], "
+  }
+  member_method {
+    name: "predict_generator"
+    argspec: "args=[\'self\', \'generator\', \'steps\', \'max_queue_size\', \'workers\', \'use_multiprocessing\', \'verbose\'], varargs=None, keywords=kwargs, defaults=[\'10\', \'1\', \'False\', \'0\'], "
+  }
+  member_method {
+    name: "predict_on_batch"
+    argspec: "args=[\'self\', \'x\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "predict_proba"
+    argspec: "args=[\'self\', \'x\', \'batch_size\', \'verbose\'], varargs=None, keywords=None, defaults=[\'32\', \'1\'], "
+  }
+  member_method {
+    name: "reset_states"
+    argspec: "args=[\'self\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "save"
+    argspec: "args=[\'self\', \'filepath\', \'overwrite\', \'include_optimizer\'], varargs=None, keywords=None, defaults=[\'True\', \'True\'], "
+  }
+  member_method {
+    name: "save_weights"
+    argspec: "args=[\'self\', \'filepath\', \'overwrite\'], varargs=None, keywords=None, defaults=[\'True\'], "
+  }
+  member_method {
+    name: "set_weights"
+    argspec: "args=[\'self\', \'weights\'], varargs=None, keywords=None, defaults=None"
+  }
+  member_method {
+    name: "summary"
+    argspec: "args=[\'self\', \'line_length\', \'positions\', \'print_fn\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\'], "
+  }
+  member_method {
+    name: "test_on_batch"
+    argspec: "args=[\'self\', \'x\', \'y\', \'sample_weight\'], varargs=None, keywords=None, defaults=[\'None\'], "
+  }
+  member_method {
+    name: "to_json"
+    argspec: "args=[\'self\'], varargs=None, keywords=kwargs, defaults=None"
+  }
+  member_method {
+    name: "to_yaml"
+    argspec: "args=[\'self\'], varargs=None, keywords=kwargs, defaults=None"
+  }
+  member_method {
+    name: "train_on_batch"
+    argspec: "args=[\'self\', \'x\', \'y\', \'class_weight\', \'sample_weight\'], varargs=None, keywords=None, defaults=[\'None\', \'None\'], "
+  }
+}
diff --git a/tensorflow/tools/api/golden/tensorflow.keras.applications.inception_resnet_v2.pbtxt b/tensorflow/tools/api/golden/tensorflow.keras.applications.inception_resnet_v2.pbtxt
new file mode 100644
index 0000000000000000000000000000000000000000..211080c19b72b744e58a15ffb08d594d24e41860
--- /dev/null
+++ b/tensorflow/tools/api/golden/tensorflow.keras.applications.inception_resnet_v2.pbtxt
@@ -0,0 +1,15 @@
+path: "tensorflow.keras.applications.inception_resnet_v2"
+tf_module {
+  member_method {
+    name: "InceptionResNetV2"
+    argspec: "args=[\'include_top\', \'weights\', \'input_tensor\', \'input_shape\', \'pooling\', \'classes\'], varargs=None, keywords=None, defaults=[\'True\', \'imagenet\', \'None\', \'None\', \'None\', \'1000\'], "
+  }
+  member_method {
+    name: "decode_predictions"
+    argspec: "args=[\'preds\', \'top\'], varargs=None, keywords=None, defaults=[\'5\'], "
+  }
+  member_method {
+    name: "preprocess_input"
+    argspec: "args=[\'x\'], varargs=None, keywords=None, defaults=None"
+  }
+}
diff --git a/tensorflow/tools/api/golden/tensorflow.keras.applications.pbtxt b/tensorflow/tools/api/golden/tensorflow.keras.applications.pbtxt
index f50dc7d7fe432d80e91c8bbfbd8cfc36b5682fb7..daeb5aad419156a19f929fdd455f6c208cd7390f 100644
--- a/tensorflow/tools/api/golden/tensorflow.keras.applications.pbtxt
+++ b/tensorflow/tools/api/golden/tensorflow.keras.applications.pbtxt
@@ -1,5 +1,9 @@
 path: "tensorflow.keras.applications"
 tf_module {
+  member {
+    name: "inception_resnet_v2"
+    mtype: "<type \'module\'>"
+  }
   member {
     name: "inception_v3"
     mtype: "<type \'module\'>"
@@ -24,6 +28,10 @@ tf_module {
     name: "xception"
     mtype: "<type \'module\'>"
   }
+  member_method {
+    name: "InceptionResNetV2"
+    argspec: "args=[\'include_top\', \'weights\', \'input_tensor\', \'input_shape\', \'pooling\', \'classes\'], varargs=None, keywords=None, defaults=[\'True\', \'imagenet\', \'None\', \'None\', \'None\', \'1000\'], "
+  }
   member_method {
     name: "InceptionV3"
     argspec: "args=[\'include_top\', \'weights\', \'input_tensor\', \'input_shape\', \'pooling\', \'classes\'], varargs=None, keywords=None, defaults=[\'True\', \'imagenet\', \'None\', \'None\', \'None\', \'1000\'], "
diff --git a/tensorflow/tools/api/golden/tensorflow.keras.applications.resnet50.pbtxt b/tensorflow/tools/api/golden/tensorflow.keras.applications.resnet50.pbtxt
index 57c48df2e365528d8c3812ec502661eb9576e89e..7385af064da4fdee87c3137f6a90057032400bf6 100644
--- a/tensorflow/tools/api/golden/tensorflow.keras.applications.resnet50.pbtxt
+++ b/tensorflow/tools/api/golden/tensorflow.keras.applications.resnet50.pbtxt
@@ -10,6 +10,6 @@ tf_module {
   }
   member_method {
     name: "preprocess_input"
-    argspec: "args=[\'x\', \'data_format\'], varargs=None, keywords=None, defaults=[\'None\'], "
+    argspec: "args=[\'x\', \'data_format\', \'mode\'], varargs=None, keywords=None, defaults=[\'None\', \'caffe\'], "
   }
 }
diff --git a/tensorflow/tools/api/golden/tensorflow.keras.applications.vgg16.pbtxt b/tensorflow/tools/api/golden/tensorflow.keras.applications.vgg16.pbtxt
index 29d45daea44cd51ef8bc4590218c3a30a7d9f39f..ba66fba8f3086d40635b9c6a9d519af913155e75 100644
--- a/tensorflow/tools/api/golden/tensorflow.keras.applications.vgg16.pbtxt
+++ b/tensorflow/tools/api/golden/tensorflow.keras.applications.vgg16.pbtxt
@@ -10,6 +10,6 @@ tf_module {
   }
   member_method {
     name: "preprocess_input"
-    argspec: "args=[\'x\', \'data_format\'], varargs=None, keywords=None, defaults=[\'None\'], "
+    argspec: "args=[\'x\', \'data_format\', \'mode\'], varargs=None, keywords=None, defaults=[\'None\', \'caffe\'], "
   }
 }
diff --git a/tensorflow/tools/api/golden/tensorflow.keras.applications.vgg19.pbtxt b/tensorflow/tools/api/golden/tensorflow.keras.applications.vgg19.pbtxt
index 124aa7e5e5dd6f9863790b86bf8c767f21304235..e55a1345b608bc1cf4911e394b9824e74c028d0d 100644
--- a/tensorflow/tools/api/golden/tensorflow.keras.applications.vgg19.pbtxt
+++ b/tensorflow/tools/api/golden/tensorflow.keras.applications.vgg19.pbtxt
@@ -10,6 +10,6 @@ tf_module {
   }
   member_method {
     name: "preprocess_input"
-    argspec: "args=[\'x\', \'data_format\'], varargs=None, keywords=None, defaults=[\'None\'], "
+    argspec: "args=[\'x\', \'data_format\', \'mode\'], varargs=None, keywords=None, defaults=[\'None\', \'caffe\'], "
   }
 }
diff --git a/tensorflow/tools/api/golden/tensorflow.keras.pbtxt b/tensorflow/tools/api/golden/tensorflow.keras.pbtxt
index 77cfe33ac47b62341ee277cbee71b29e9259830a..754b3b84b08b08c7d12eba4ddad0a483440055a9 100644
--- a/tensorflow/tools/api/golden/tensorflow.keras.pbtxt
+++ b/tensorflow/tools/api/golden/tensorflow.keras.pbtxt
@@ -1,5 +1,13 @@
 path: "tensorflow.keras"
 tf_module {
+  member {
+    name: "Model"
+    mtype: "<type \'type\'>"
+  }
+  member {
+    name: "Sequential"
+    mtype: "<type \'type\'>"
+  }
   member {
     name: "activations"
     mtype: "<type \'module\'>"
diff --git a/tensorflow/tools/api/golden/tensorflow.linalg.pbtxt b/tensorflow/tools/api/golden/tensorflow.linalg.pbtxt
index 0d62585ff45b396daf44988a699a308c5a16b772..62e634afb87b9dcc02ab0ceaaa7bdff62f9bfefa 100644
--- a/tensorflow/tools/api/golden/tensorflow.linalg.pbtxt
+++ b/tensorflow/tools/api/golden/tensorflow.linalg.pbtxt
@@ -72,6 +72,10 @@ tf_module {
     name: "einsum"
     argspec: "args=[\'equation\'], varargs=inputs, keywords=kwargs, defaults=None"
   }
+  member_method {
+    name: "expm"
+    argspec: "args=[\'input\', \'name\'], varargs=None, keywords=None, defaults=[\'None\'], "
+  }
   member_method {
     name: "eye"
     argspec: "args=[\'num_rows\', \'num_columns\', \'batch_shape\', \'dtype\', \'name\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \"<dtype: \'float32\'>\", \'None\'], "
@@ -90,7 +94,7 @@ tf_module {
   }
   member_method {
     name: "norm"
-    argspec: "args=[\'tensor\', \'ord\', \'axis\', \'keep_dims\', \'name\'], varargs=None, keywords=None, defaults=[\'euclidean\', \'None\', \'False\', \'None\'], "
+    argspec: "args=[\'tensor\', \'ord\', \'axis\', \'keepdims\', \'name\', \'keep_dims\'], varargs=None, keywords=None, defaults=[\'euclidean\', \'None\', \'None\', \'None\', \'None\'], "
   }
   member_method {
     name: "qr"
diff --git a/tensorflow/tools/api/golden/tensorflow.metrics.pbtxt b/tensorflow/tools/api/golden/tensorflow.metrics.pbtxt
index 6932b330be06f68e6301414139d7c7ba42ab3410..85088834b7987c6ff8689902a31e4e4dc9aff248 100644
--- a/tensorflow/tools/api/golden/tensorflow.metrics.pbtxt
+++ b/tensorflow/tools/api/golden/tensorflow.metrics.pbtxt
@@ -8,6 +8,10 @@ tf_module {
     name: "auc"
     argspec: "args=[\'labels\', \'predictions\', \'weights\', \'num_thresholds\', \'metrics_collections\', \'updates_collections\', \'curve\', \'name\', \'summation_method\'], varargs=None, keywords=None, defaults=[\'None\', \'200\', \'None\', \'None\', \'ROC\', \'None\', \'trapezoidal\'], "
   }
+  member_method {
+    name: "average_precision_at_k"
+    argspec: "args=[\'labels\', \'predictions\', \'k\', \'weights\', \'metrics_collections\', \'updates_collections\', \'name\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'None\'], "
+  }
   member_method {
     name: "false_negatives"
     argspec: "args=[\'labels\', \'predictions\', \'weights\', \'metrics_collections\', \'updates_collections\', \'name\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'None\'], "
@@ -64,6 +68,10 @@ tf_module {
     name: "precision"
     argspec: "args=[\'labels\', \'predictions\', \'weights\', \'metrics_collections\', \'updates_collections\', \'name\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'None\'], "
   }
+  member_method {
+    name: "precision_at_k"
+    argspec: "args=[\'labels\', \'predictions\', \'k\', \'class_id\', \'weights\', \'metrics_collections\', \'updates_collections\', \'name\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'None\', \'None\'], "
+  }
   member_method {
     name: "precision_at_thresholds"
     argspec: "args=[\'labels\', \'predictions\', \'thresholds\', \'weights\', \'metrics_collections\', \'updates_collections\', \'name\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'None\'], "
diff --git a/tensorflow/tools/api/golden/tensorflow.pbtxt b/tensorflow/tools/api/golden/tensorflow.pbtxt
index 69a52425eb7bd4af4f396b62c11ec9e84189ad70..0edd4153d772459d941cb260c26fd9e09f017f12 100644
--- a/tensorflow/tools/api/golden/tensorflow.pbtxt
+++ b/tensorflow/tools/api/golden/tensorflow.pbtxt
@@ -858,7 +858,7 @@ tf_module {
   }
   member_method {
     name: "count_nonzero"
-    argspec: "args=[\'input_tensor\', \'axis\', \'keep_dims\', \'dtype\', \'name\', \'reduction_indices\'], varargs=None, keywords=None, defaults=[\'None\', \'False\', \"<dtype: \'int64\'>\", \'None\', \'None\'], "
+    argspec: "args=[\'input_tensor\', \'axis\', \'keepdims\', \'dtype\', \'name\', \'reduction_indices\', \'keep_dims\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \"<dtype: \'int64\'>\", \'None\', \'None\', \'None\'], "
   }
   member_method {
     name: "count_up_to"
@@ -1414,7 +1414,7 @@ tf_module {
   }
   member_method {
     name: "norm"
-    argspec: "args=[\'tensor\', \'ord\', \'axis\', \'keep_dims\', \'name\'], varargs=None, keywords=None, defaults=[\'euclidean\', \'None\', \'False\', \'None\'], "
+    argspec: "args=[\'tensor\', \'ord\', \'axis\', \'keepdims\', \'name\', \'keep_dims\'], varargs=None, keywords=None, defaults=[\'euclidean\', \'None\', \'None\', \'None\', \'None\'], "
   }
   member_method {
     name: "not_equal"
@@ -1546,11 +1546,11 @@ tf_module {
   }
   member_method {
     name: "reduce_all"
-    argspec: "args=[\'input_tensor\', \'axis\', \'keep_dims\', \'name\', \'reduction_indices\'], varargs=None, keywords=None, defaults=[\'None\', \'False\', \'None\', \'None\'], "
+    argspec: "args=[\'input_tensor\', \'axis\', \'keepdims\', \'name\', \'reduction_indices\', \'keep_dims\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'None\', \'None\'], "
   }
   member_method {
     name: "reduce_any"
-    argspec: "args=[\'input_tensor\', \'axis\', \'keep_dims\', \'name\', \'reduction_indices\'], varargs=None, keywords=None, defaults=[\'None\', \'False\', \'None\', \'None\'], "
+    argspec: "args=[\'input_tensor\', \'axis\', \'keepdims\', \'name\', \'reduction_indices\', \'keep_dims\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'None\', \'None\'], "
   }
   member_method {
     name: "reduce_join"
@@ -1558,27 +1558,27 @@ tf_module {
   }
   member_method {
     name: "reduce_logsumexp"
-    argspec: "args=[\'input_tensor\', \'axis\', \'keep_dims\', \'name\', \'reduction_indices\'], varargs=None, keywords=None, defaults=[\'None\', \'False\', \'None\', \'None\'], "
+    argspec: "args=[\'input_tensor\', \'axis\', \'keepdims\', \'name\', \'reduction_indices\', \'keep_dims\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'None\', \'None\'], "
   }
   member_method {
     name: "reduce_max"
-    argspec: "args=[\'input_tensor\', \'axis\', \'keep_dims\', \'name\', \'reduction_indices\'], varargs=None, keywords=None, defaults=[\'None\', \'False\', \'None\', \'None\'], "
+    argspec: "args=[\'input_tensor\', \'axis\', \'keepdims\', \'name\', \'reduction_indices\', \'keep_dims\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'None\', \'None\'], "
   }
   member_method {
     name: "reduce_mean"
-    argspec: "args=[\'input_tensor\', \'axis\', \'keep_dims\', \'name\', \'reduction_indices\'], varargs=None, keywords=None, defaults=[\'None\', \'False\', \'None\', \'None\'], "
+    argspec: "args=[\'input_tensor\', \'axis\', \'keepdims\', \'name\', \'reduction_indices\', \'keep_dims\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'None\', \'None\'], "
   }
   member_method {
     name: "reduce_min"
-    argspec: "args=[\'input_tensor\', \'axis\', \'keep_dims\', \'name\', \'reduction_indices\'], varargs=None, keywords=None, defaults=[\'None\', \'False\', \'None\', \'None\'], "
+    argspec: "args=[\'input_tensor\', \'axis\', \'keepdims\', \'name\', \'reduction_indices\', \'keep_dims\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'None\', \'None\'], "
   }
   member_method {
     name: "reduce_prod"
-    argspec: "args=[\'input_tensor\', \'axis\', \'keep_dims\', \'name\', \'reduction_indices\'], varargs=None, keywords=None, defaults=[\'None\', \'False\', \'None\', \'None\'], "
+    argspec: "args=[\'input_tensor\', \'axis\', \'keepdims\', \'name\', \'reduction_indices\', \'keep_dims\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'None\', \'None\'], "
   }
   member_method {
     name: "reduce_sum"
-    argspec: "args=[\'input_tensor\', \'axis\', \'keep_dims\', \'name\', \'reduction_indices\'], varargs=None, keywords=None, defaults=[\'None\', \'False\', \'None\', \'None\'], "
+    argspec: "args=[\'input_tensor\', \'axis\', \'keepdims\', \'name\', \'reduction_indices\', \'keep_dims\'], varargs=None, keywords=None, defaults=[\'None\', \'None\', \'None\', \'None\', \'None\'], "
   }
   member_method {
     name: "register_tensor_conversion_function"
diff --git a/tensorflow/tools/api/tests/api_compatibility_test.py b/tensorflow/tools/api/tests/api_compatibility_test.py
index 6a27f6bc42fb3205b95384b66cb9d0f29f26fa55..a8fdf4c9a07a21269920c61d7f560562dab7b5f4 100644
--- a/tensorflow/tools/api/tests/api_compatibility_test.py
+++ b/tensorflow/tools/api/tests/api_compatibility_test.py
@@ -29,7 +29,6 @@ from __future__ import print_function
 
 import argparse
 from collections import defaultdict
-from operator import attrgetter
 import os
 import re
 import subprocess
@@ -68,7 +67,6 @@ _API_GOLDEN_FOLDER = 'tensorflow/tools/api/golden'
 _TEST_README_FILE = 'tensorflow/tools/api/tests/README.txt'
 _UPDATE_WARNING_FILE = 'tensorflow/tools/api/tests/API_UPDATE_WARNING.txt'
 
-_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 _CONVERT_FROM_MULTILINE_SCRIPT = 'tensorflow/tools/api/tests/convert_from_multiline'
 _BASE_API_DIR = 'tensorflow/core/api_def/base_api'
 _PYTHON_API_DIR = 'tensorflow/core/api_def/python_api'
@@ -137,6 +135,16 @@ def _GetHiddenOps():
   return hidden_ops
 
 
+def _GetGoldenApiDefs():
+  old_api_def_files = file_io.get_matching_files(_GetApiDefFilePath('*'))
+  return {file_path: file_io.read_file_to_string(file_path)
+          for file_path in old_api_def_files}
+
+
+def _GetApiDefFilePath(graph_op_name):
+  return os.path.join(_PYTHON_API_DIR, 'api_def_%s.pbtxt' % graph_op_name)
+
+
 class ApiCompatibilityTest(test.TestCase):
 
   def __init__(self, *args, **kwargs):
@@ -302,6 +310,14 @@ class ApiDefTest(test.TestCase):
       endpoints in base_api_def. Otherwise, returns None.
     """
     endpoint_names_set = set(endpoint_names)
+
+    # If the only endpoint is equal to graph_op_name then
+    # it is equivalent to having no endpoints.
+    if (not base_api_def.endpoint and len(endpoint_names) == 1
+        and endpoint_names[0] ==
+        self._GenerateLowerCaseOpName(base_api_def.graph_op_name)):
+      return None
+
     base_endpoint_names_set = {
         self._GenerateLowerCaseOpName(endpoint.name)
         for endpoint in base_api_def.endpoint}
@@ -349,8 +365,8 @@ class ApiDefTest(test.TestCase):
 
     Args:
       name_to_base_api_def: Map from op name to base api_def_pb2.ApiDef.
-      api_def_map: Map from first op name character (in caps) to
-        api_def_pb2.ApiDefs for Python API overrides.
+      api_def_map: Map from file path to api_def_pb2.ApiDefs for Python API
+        overrides.
     """
     hidden_ops = _GetHiddenOps()
     for hidden_op in hidden_ops:
@@ -363,7 +379,9 @@ class ApiDefTest(test.TestCase):
         api_def = api_def_pb2.ApiDef()
         api_def.graph_op_name = base_api_def.graph_op_name
         api_def.visibility = api_def_pb2.ApiDef.HIDDEN
-        api_def_map[api_def.graph_op_name[0].upper()].op.extend([api_def])
+
+        file_path = _GetApiDefFilePath(base_api_def.graph_op_name)
+        api_def_map[file_path].op.extend([api_def])
 
   @unittest.skipUnless(
       sys.version_info.major == 2 and os.uname()[0] == 'Linux',
@@ -381,8 +399,8 @@ class ApiDefTest(test.TestCase):
     traverse.traverse(tf, public_api_visitor)
     proto_dict = visitor.GetProtos()
 
-    # Map from first character of op name to Python ApiDefs.
-    api_def_map = defaultdict(api_def_pb2.ApiDefs)
+    # Map from file path to Python ApiDefs.
+    new_api_defs_map = defaultdict(api_def_pb2.ApiDefs)
     # We need to override all endpoints even if 1 endpoint differs from base
     # ApiDef. So, we first create a map from an op to all its endpoints.
     op_to_endpoint_name = defaultdict(list)
@@ -410,43 +428,45 @@ class ApiDefTest(test.TestCase):
       graph_op_name = snake_to_camel_graph_op_names[op.__name__]
       api_def = self._CreatePythonApiDef(
           name_to_base_api_def[graph_op_name], endpoint_names)
+
       if api_def:
-        api_defs = api_def_map[graph_op_name[0].upper()]
+        file_path = _GetApiDefFilePath(graph_op_name)
+        api_defs = new_api_defs_map[file_path]
         api_defs.op.extend([api_def])
 
-    self._AddHiddenOpOverrides(name_to_base_api_def, api_def_map)
+    self._AddHiddenOpOverrides(name_to_base_api_def, new_api_defs_map)
 
-    for key in _ALPHABET:
-      # Get new ApiDef for the given key.
-      new_api_defs_str = ''
-      if key in api_def_map:
-        new_api_defs = api_def_map[key]
-        new_api_defs.op.sort(key=attrgetter('graph_op_name'))
-        new_api_defs_str = str(new_api_defs)
+    old_api_defs_map = _GetGoldenApiDefs()
+    for file_path, new_api_defs in new_api_defs_map.items():
+      # Get new ApiDef string.
+      new_api_defs_str = str(new_api_defs)
 
-      # Get current ApiDef for the given key.
-      api_defs_file_path = os.path.join(
-          _PYTHON_API_DIR, 'api_def_%s.pbtxt' % key)
-      old_api_defs_str = ''
-      if file_io.file_exists(api_defs_file_path):
-        old_api_defs_str = file_io.read_file_to_string(api_defs_file_path)
+      # Get current ApiDef for the given file.
+      old_api_defs_str = (
+          old_api_defs_map[file_path] if file_path in old_api_defs_map else '')
 
       if old_api_defs_str == new_api_defs_str:
         continue
 
       if FLAGS.update_goldens:
-        if not new_api_defs_str:
-          logging.info('Deleting %s...' % api_defs_file_path)
-          file_io.delete_file(api_defs_file_path)
-        else:
-          logging.info('Updating %s...' % api_defs_file_path)
-          file_io.write_string_to_file(api_defs_file_path, new_api_defs_str)
+        logging.info('Updating %s...' % file_path)
+        file_io.write_string_to_file(file_path, new_api_defs_str)
       else:
         self.assertMultiLineEqual(
             old_api_defs_str, new_api_defs_str,
             'To update golden API files, run api_compatibility_test locally '
             'with --update_goldens=True flag.')
 
+    for file_path in set(old_api_defs_map) - set(new_api_defs_map):
+      if FLAGS.update_goldens:
+        logging.info('Deleting %s...' % file_path)
+        file_io.delete_file(file_path)
+      else:
+        self.fail(
+            '%s file is no longer needed and should be removed.'
+            'To update golden API files, run api_compatibility_test locally '
+            'with --update_goldens=True flag.' % file_path)
+
 
 if __name__ == '__main__':
   parser = argparse.ArgumentParser()
diff --git a/tensorflow/tools/ci_build/install/install_pip_packages.sh b/tensorflow/tools/ci_build/install/install_pip_packages.sh
index 352af871082ed7d88bda0067b268e90c2bb88615..b8ed1ab7676ff4efaef01dd5009effbf5ab05a92 100755
--- a/tensorflow/tools/ci_build/install/install_pip_packages.sh
+++ b/tensorflow/tools/ci_build/install/install_pip_packages.sh
@@ -31,6 +31,10 @@ pip3 install wheel
 pip2 install --upgrade six==1.10.0
 pip3 install --upgrade six==1.10.0
 
+# Install absl-py.
+pip2 install --upgrade absl-py
+pip3 install --upgrade absl-py
+
 # Install werkzeug.
 pip2 install --upgrade werkzeug==0.11.10
 pip3 install --upgrade werkzeug==0.11.10
diff --git a/tensorflow/tools/ci_build/install/install_python3.5_pip_packages.sh b/tensorflow/tools/ci_build/install/install_python3.5_pip_packages.sh
index e452c50221bee4385db27856f05c539798e2ba53..81bce95d543953a0b97dca79b02babc4999623bb 100755
--- a/tensorflow/tools/ci_build/install/install_python3.5_pip_packages.sh
+++ b/tensorflow/tools/ci_build/install/install_python3.5_pip_packages.sh
@@ -61,6 +61,7 @@ fi
 
 set -e
 # Install six.
+pip3.5 install --upgrade absl-py
 pip3.5 install --upgrade six==1.10.0
 
 # Install protobuf.
diff --git a/tensorflow/tools/ci_build/windows/cpu/cmake/run_py.bat b/tensorflow/tools/ci_build/windows/cpu/cmake/run_py.bat
index 2f6d53e171ce5236ca48a07756335ac723f88381..3c3b223a0044b7136ea4dee20fa72cd2fed3742a 100644
--- a/tensorflow/tools/ci_build/windows/cpu/cmake/run_py.bat
+++ b/tensorflow/tools/ci_build/windows/cpu/cmake/run_py.bat
@@ -37,6 +37,9 @@ DIR %REPO_ROOT%\%BUILD_DIR%\tf_python\dist\ /S /B > wheel_filename_file
 set /p WHEEL_FILENAME=<wheel_filename_file
 del wheel_filename_file
 
+:: Install absl-py.
+%PIP_EXE% install --upgrade absl-py
+
 :: Install the pip package.
 echo Installing PIP package...
 %PIP_EXE% install --upgrade --no-deps %WHEEL_FILENAME% -v -v
diff --git a/tensorflow/tools/ci_build/windows/gpu/cmake/run_py.bat b/tensorflow/tools/ci_build/windows/gpu/cmake/run_py.bat
index 02e24c85de1deb6d7df2e16200cfed7e6d582c28..b537192a945b2a2d8c2df940b947c6c0f7d6fc06 100644
--- a/tensorflow/tools/ci_build/windows/gpu/cmake/run_py.bat
+++ b/tensorflow/tools/ci_build/windows/gpu/cmake/run_py.bat
@@ -37,6 +37,9 @@ DIR %REPO_ROOT%\%BUILD_DIR%\tf_python\dist\ /S /B > wheel_filename_file
 set /p WHEEL_FILENAME=<wheel_filename_file
 del wheel_filename_file
 
+:: Install absl-py.
+%PIP_EXE% install --upgrade absl-py
+
 :: Install the pip package.
 echo Installing PIP package...
 %PIP_EXE% install --upgrade --no-deps %WHEEL_FILENAME% -v -v
diff --git a/tensorflow/tools/docs/generate_lib.py b/tensorflow/tools/docs/generate_lib.py
index 9b8b50f9cd5a108f0e553291a1c19ad6c69af7c9..c0cde1d3bdd9023479a19112df36d3d88411da67 100644
--- a/tensorflow/tools/docs/generate_lib.py
+++ b/tensorflow/tools/docs/generate_lib.py
@@ -152,19 +152,36 @@ def write_docs(output_dir, parser_config, yaml_toc, root_title='TensorFlow'):
       # Generate header
       f.write('# Automatically generated file; please do not edit\ntoc:\n')
       for module in modules:
-        f.write('  - title: ' + module + '\n'
-                '    section:\n' + '    - title: Overview\n' +
-                '      path: /TARGET_DOC_ROOT/VERSION/' + symbol_to_file[module]
-                + '\n')
+        indent_num = module.count('.')
+        # Don't list `tf.submodule` inside `tf`
+        indent_num = max(indent_num, 1)
+        indent = '  '*indent_num
+
+        if indent_num > 1:
+          # tf.contrib.baysflow.entropy will be under
+          #   tf.contrib->baysflow->entropy
+          title = module.split('.')[-1]
+        else:
+          title = module
+
+        header = [
+            '- title: ' + title,
+            '  section:',
+            '  - title: Overview',
+            '    path: /TARGET_DOC_ROOT/VERSION/' + symbol_to_file[module]]
+        header = ''.join([indent+line+'\n' for line in header])
+        f.write(header)
 
         symbols_in_module = module_children.get(module, [])
         # Sort case-insensitive, if equal sort case sensitive (upper first)
         symbols_in_module.sort(key=lambda a: (a.upper(), a))
 
         for full_name in symbols_in_module:
-          f.write('    - title: ' + full_name[len(module) + 1:] + '\n'
-                  '      path: /TARGET_DOC_ROOT/VERSION/' +
-                  symbol_to_file[full_name] + '\n')
+          item = [
+              '  - title: ' + full_name[len(module) + 1:],
+              '    path: /TARGET_DOC_ROOT/VERSION/' + symbol_to_file[full_name]]
+          item = ''.join([indent+line+'\n' for line in item])
+          f.write(item)
 
   # Write a global index containing all full names with links.
   with open(os.path.join(output_dir, 'index.md'), 'w') as f:
diff --git a/tensorflow/tools/graph_transforms/BUILD b/tensorflow/tools/graph_transforms/BUILD
index 1bf7113c9ee07c0ade3d2396f277447c06fa7a78..9216008600b0969ae95a985f54511a24f4fac3e7 100644
--- a/tensorflow/tools/graph_transforms/BUILD
+++ b/tensorflow/tools/graph_transforms/BUILD
@@ -131,6 +131,8 @@ cc_library(
         "//tensorflow/core:lib",
         "//tensorflow/core:protos_all_cc",
         "//tensorflow/core:tensorflow",
+        "//tensorflow/contrib/rnn:gru_ops_op_lib",
+        "//tensorflow/contrib/rnn:lstm_ops_op_lib",
     ] + if_not_windows([
         "//tensorflow/core/kernels:quantized_ops",
         "//tensorflow/core/kernels:remote_fused_graph_rewriter_transform",
diff --git a/tensorflow/tools/pip_package/setup.py b/tensorflow/tools/pip_package/setup.py
index 071b3a2a1888c39e0a22b92edbeecfaa06c8ea83..0c54300e06a25a3fc1b1b0563c167f14dba7ecae 100644
--- a/tensorflow/tools/pip_package/setup.py
+++ b/tensorflow/tools/pip_package/setup.py
@@ -29,9 +29,10 @@ from setuptools.dist import Distribution
 # This version string is semver compatible, but incompatible with pip.
 # For pip, we will remove all '-' characters from this string, and use the
 # result for pip.
-_VERSION = '1.4.0-rc1'
+_VERSION = '1.4.0'
 
 REQUIRED_PACKAGES = [
+    'absl-py',
     'enum34 >= 1.1.6',
     'numpy >= 1.12.1',
     'six >= 1.10.0',
diff --git a/tensorflow/workspace.bzl b/tensorflow/workspace.bzl
index 0173f5a0d446f66010b06b0c3fab81e6ca13f582..afcae6eade1d19ea707b794ba05067cac77e6d86 100644
--- a/tensorflow/workspace.bzl
+++ b/tensorflow/workspace.bzl
@@ -354,6 +354,15 @@ def tf_workspace(path_prefix="", tf_repo_name=""):
       build_file = str(Label("//third_party:six.BUILD")),
   )
 
+  native.http_archive(
+      name = "absl_py",
+      urls = [
+          "https://github.com/abseil/abseil-py/archive/231e3870b976c1dc61dce1749138661d21556028.tar.gz",
+      ],
+      sha256 = "8ea2b23bfdb9ae7622f3e5d95236bc600c8d8509a2f38c84732b3145585d4f73",
+      strip_prefix = "abseil-py-231e3870b976c1dc61dce1749138661d21556028",
+  )
+
   native.new_http_archive(
       name = "org_python_pypi_backports_weakref",
       urls = [
@@ -439,11 +448,11 @@ def tf_workspace(path_prefix="", tf_repo_name=""):
   native.http_archive(
       name = "nsync",
       urls = [
-          "https://mirror.bazel.build/github.com/google/nsync/archive/839fcc53ff9be58218ed55397deb3f8376a1444e.tar.gz",
-          # "https://github.com/google/nsync/archive/839fcc53ff9be58218ed55397deb3f8376a1444e.tar.gz",
+          "https://mirror.bazel.build/github.com/google/nsync/archive/4fc8ff3e7626c5f24bc9674438d8257f0ffc226c.tar.gz",
+          # "https://github.com/google/nsync/archive/4fc8ff3e7626c5f24bc9674438d8257f0ffc226c.tar.gz",
       ],
-      sha256 = "124d105edb0313ef2d7f5bb86ec94d9f8de95479e55641c4254ffa8f795e9b37",
-      strip_prefix = "nsync-839fcc53ff9be58218ed55397deb3f8376a1444e",
+      sha256 = "ffbbe828f3d0bef75462e34801de5cea31d10aa63eaa42a4ed74c46521bdfd58",
+      strip_prefix = "nsync-4fc8ff3e7626c5f24bc9674438d8257f0ffc226c",
   )
 
   native.http_archive(
@@ -564,11 +573,11 @@ def tf_workspace(path_prefix="", tf_repo_name=""):
   temp_workaround_http_archive(
       name = "llvm",
       urls = [
-          "https://mirror.bazel.build/github.com/llvm-mirror/llvm/archive/bb3c660e87f59abb665570a31b01ab125ec4c10e.tar.gz",
-          "https://github.com/llvm-mirror/llvm/archive/bb3c660e87f59abb665570a31b01ab125ec4c10e.tar.gz",
+          "https://mirror.bazel.build/github.com/llvm-mirror/llvm/archive/618cf290880ae9cd87b4bbf6c9b1759476f422eb.tar.gz",
+          "https://github.com/llvm-mirror/llvm/archive/618cf290880ae9cd87b4bbf6c9b1759476f422eb.tar.gz",
       ],
-      sha256 = "caab6d7978e6771cb4e9b5b89607c5370de8aa642913c6c14e892468194c94e4",
-      strip_prefix = "llvm-bb3c660e87f59abb665570a31b01ab125ec4c10e",
+      sha256 = "ec2e032e58372c614c41b539c0309baa91843c30d7a9c6dee647dcd24be02e3c",
+      strip_prefix = "llvm-618cf290880ae9cd87b4bbf6c9b1759476f422eb",
       build_file = str(Label("//third_party/llvm:llvm.BUILD")),
       repository = tf_repo_name,
   )
diff --git a/third_party/eigen.BUILD b/third_party/eigen.BUILD
index dc6de7bbda172ff9cb22c89b84341e4087ef76d3..07bb6645ebc2faa47ed7d52dc0e5975e55f0ed32 100644
--- a/third_party/eigen.BUILD
+++ b/third_party/eigen.BUILD
@@ -27,7 +27,6 @@ EIGEN_RESTRICTED_DEPS = [
     "Eigen/SparseLU",
 ]
 
-# Note: unsupported/Eigen is unsupported and might go away at any time.
 EIGEN_FILES = [
     "Eigen/**",
     "unsupported/Eigen/CXX11/**",
@@ -37,6 +36,7 @@ EIGEN_FILES = [
     "unsupported/Eigen/src/KroneckerProduct/**",
     "unsupported/Eigen/MatrixFunctions",
     "unsupported/Eigen/SpecialFunctions",
+    "unsupported/Eigen/src/MatrixFunctions/**",
     "unsupported/Eigen/src/SpecialFunctions/**",
 ]
 
diff --git a/third_party/eigen3/BUILD b/third_party/eigen3/BUILD
index ad87477b7aa304581c9164d3d10574c1069f03cc..f5f3418527f2ae0a948ac15645ebd905b59bcabf 100644
--- a/third_party/eigen3/BUILD
+++ b/third_party/eigen3/BUILD
@@ -26,6 +26,7 @@ cc_library(
         "Eigen/Eigenvalues",
         "Eigen/QR",
         "Eigen/SVD",
+        "unsupported/Eigen/MatrixFunctions",
         "unsupported/Eigen/SpecialFunctions",
         "unsupported/Eigen/CXX11/ThreadPool",
         "unsupported/Eigen/CXX11/Tensor",
diff --git a/third_party/eigen3/unsupported/Eigen/MatrixFunctions b/third_party/eigen3/unsupported/Eigen/MatrixFunctions
new file mode 100644
index 0000000000000000000000000000000000000000..314b325f8c293e1942a0fce82bc123b1bd7d5733
--- /dev/null
+++ b/third_party/eigen3/unsupported/Eigen/MatrixFunctions
@@ -0,0 +1 @@
+#include "unsupported/Eigen/MatrixFunctions"