From 9dffbd06c7a9a352b523add2239b032deaf1ac29 Mon Sep 17 00:00:00 2001
From: Karl Lessard <karl.lessard@gmail.com>
Date: Thu, 26 Mar 2020 22:06:22 -0400
Subject: [PATCH 1/7] Rollback operator 'val' to 'constant'

---
 .../annotations/org/tensorflow/op/Ops.java    | 9485 +++++++++--------
 .../src/main/java/org/tensorflow/Operand.java |    2 +-
 .../src/main/java/org/tensorflow/Tensor.java  |    2 +-
 .../java/org/tensorflow/op/core/Constant.java |  136 +-
 .../org/tensorflow/op/core/Gradients.java     |    2 +-
 .../java/org/tensorflow/op/core/Zeros.java    |    4 +-
 .../tensorflow/EagerOperationBuilderTest.java |   22 +-
 .../org/tensorflow/EagerOperationTest.java    |   22 +-
 .../tensorflow/GraphOperationBuilderTest.java |   10 +-
 .../org/tensorflow/GraphOperationTest.java    |   32 +-
 .../test/java/org/tensorflow/GraphTest.java   |   12 +-
 .../test/java/org/tensorflow/SessionTest.java |    8 +-
 .../test/java/org/tensorflow/TensorTest.java  |    2 +-
 .../java/org/tensorflow/op/OperandsTest.java  |    2 +-
 .../org/tensorflow/op/PrimitiveOpTest.java    |    2 +-
 .../op/core/GeneratedOperationsTest.java      |   14 +-
 .../types/NumericTypesTestBase.java           |    6 +-
 .../processor/operator/OperatorProcessor.java |   10 +-
 .../training/optimizers/AdaDelta.java         |   10 +-
 .../training/optimizers/AdaGrad.java          |    4 +-
 .../training/optimizers/AdaGradDA.java        |   16 +-
 .../tensorflow/training/optimizers/Adam.java  |   16 +-
 .../training/optimizers/GradientDescent.java  |    2 +-
 .../training/optimizers/Momentum.java         |    6 +-
 .../training/optimizers/RMSProp.java          |   22 +-
 25 files changed, 4925 insertions(+), 4924 deletions(-)

diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/Ops.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/Ops.java
index e57157c6b32..ff1ec5e3fab 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/Ops.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/Ops.java
@@ -283,13 +283,13 @@
  *   Ops tf = Ops.create(g);
  *   // Operations are typed classes with convenience
  *   // builders in Ops.
- *   Constant<TInt32> three = tf.val(3);
+ *   Constant<TInt32> three = tf.constant(3);
  *   // Single-result operations implement the Operand
  *   // interface, so this works too.
- *   Operand<TInt32> four = tf.val(4);
+ *   Operand<TInt32> four = tf.constant(4);
  *   // Most builders are found within a group, and accept
  *   // Operand types as operands
- *   Operand<TInt32> nine = tf.math.add(four, tf.val(5));
+ *   Operand<TInt32> nine = tf.math.add(four, tf.constant(5));
  *   // Multi-result operations however offer methods to
  *   // select a particular result for use.
  *   Operand<TInt32> result = 
@@ -297,10 +297,10 @@
  *   // Optional attributes
  *   tf.linalg.matMul(a, b, MatMul.transposeA(true));
  *   // Naming operators
- *   tf.withName("foo").val(5); // name "foo"
+ *   tf.withName("foo").constant(5); // name "foo"
  *   // Names can exist in a hierarchy
  *   Ops sub = tf.withSubScope("sub");
- *   sub.withName("bar").val(4); // "sub/bar"
+ *   sub.withName("bar").constant(4); // "sub/bar"
  * }
  * }</pre>
  */
@@ -1082,4731 +1082,3793 @@ public <T extends TType, U extends TNumber> Concat<T> concat(Iterable<Operand<T>
   }
 
   /**
-   * This op consumes a lock created by `MutexLock`.
-   *  <p>
-   *  This op exists to consume a tensor created by `MutexLock` (other than
-   *  direct control dependencies).  It should be the only that consumes the tensor,
-   *  and will raise an error if it is not.  Its only purpose is to keep the
-   *  mutex lock tensor alive until it is consumed by this op.
-   *  <p>
-   *  <b>NOTE</b>: This operation must run on the same device as its input.  This may
-   *  be enforced via the `colocate_with` mechanism.
+   * Creates a rank-1 constant of {@code int} elements.
    *
-   * @param mutexLock A tensor returned by `MutexLock`.
-   * @return a new instance of ConsumeMutexLock
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return an integer constant
    */
-  public ConsumeMutexLock consumeMutexLock(Operand<?> mutexLock) {
-    return ConsumeMutexLock.create(scope, mutexLock);
+  public Constant<TInt32> constant(int[] data) {
+    return Constant.vectorOf(scope, data);
   }
 
   /**
-   * Does nothing. Serves as a control trigger for scheduling.
-   *  <p>
-   *  Only useful as a placeholder for control edges.
+   * Creates a rank-3 constant of {@code int} elements.
    *
-   * @return a new instance of ControlTrigger
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return an integer constant
    */
-  public ControlTrigger controlTrigger() {
-    return ControlTrigger.create(scope);
+  public Constant<TInt32> constant(int[][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Increments 'ref' until it reaches 'limit'.
+   * Creates a constant containing a single {@code double} element.
    *
-   * @param <T> data type for {@code output()} output
-   * @param ref Should be from a scalar `Variable` node.
-   * @param limit If incrementing ref would bring it above limit, instead generates an
-   *  'OutOfRange' error.
-   * @return a new instance of CountUpTo
+   * @param scope is a scope used to add the underlying operation.
+   * @param data The value to put into the new constant.
+   * @return a double constant
    */
-  public <T extends TNumber> CountUpTo<T> countUpTo(Operand<T> ref, Long limit) {
-    return CountUpTo.create(scope, ref, limit);
+  public Constant<TFloat64> constant(double data) {
+    return Constant.scalarOf(scope, data);
   }
 
   /**
-   * Makes a copy of `x`.
+   * Creates a rank-5 constant of {@code long} elements.
    *
-   * @param <T> data type for {@code y()} output
-   * @param x The source tensor of type `T`.
-   * @return a new instance of DeepCopy
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a long constant
    */
-  public <T extends TType> DeepCopy<T> deepCopy(Operand<T> x) {
-    return DeepCopy.create(scope, x);
+  public Constant<TInt64> constant(long[][][][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Delete the tensor specified by its handle in the session.
+   * Creates a rank-5 constant of {@code boolean} elements.
    *
-   * @param handle The handle for a tensor stored in the session state.
-   * @return a new instance of DeleteSessionTensor
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a boolean constant
    */
-  public DeleteSessionTensor deleteSessionTensor(Operand<TString> handle) {
-    return DeleteSessionTensor.create(scope, handle);
+  public Constant<TBool> constant(boolean[][][][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Deletes the resource specified by the handle.
-   *  <p>
-   *  All subsequent operations using the resource will result in a NotFound
-   *  error status.
+   * Creates a rank-4 constant of {@code int} elements.
    *
-   * @param resource handle to the resource to delete.
-   * @param options carries optional attributes values
-   * @return a new instance of DestroyResourceOp
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return an integer constant
    */
-  public DestroyResourceOp destroyResourceOp(Operand<?> resource,
-      DestroyResourceOp.Options... options) {
-    return DestroyResourceOp.create(scope, resource, options);
+  public Constant<TInt32> constant(int[][][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Destroys the temporary variable and returns its final value.
-   *  <p>
-   *  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' <i>must</i> have executed before this op.
-   *  This is typically achieved by chaining the ref through each assign op, or by
-   *  using control dependencies.
-   *  <p>
-   *  Outputs the final value of the tensor pointed to by 'ref'.
+   * Creates a rank-6 constant of {@code float} elements.
    *
-   * @param <T> data type for {@code value()} output
-   * @param ref A reference to the temporary variable tensor.
-   * @param varName Name of the temporary variable, usually the name of the matching
-   *  'TemporaryVariable' op.
-   * @return a new instance of DestroyTemporaryVariable
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a float constant
    */
-  public <T extends TType> DestroyTemporaryVariable<T> destroyTemporaryVariable(Operand<T> ref,
-      String varName) {
-    return DestroyTemporaryVariable.create(scope, ref, varName);
+  public Constant<TFloat32> constant(float[][][][][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Partitions `data` into `num_partitions` tensors using indices from `partitions`.
-   *  <p>
-   *  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,
-   *  <pre>{@code
-   *      outputs[i].shape = [sum(partitions == i)] + data.shape[partitions.ndim:]
-   *
-   *      outputs[i] = pack([data[js, ...] for js if partitions[js] == i])
-   *  }</pre>
-   *  `data.shape` must start with `partitions.shape`.
-   *  <p>
-   *  For example:
-   *  <pre>{@code
-   *      # 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]
-   *  }</pre>
-   *  See `dynamic_stitch` for an example on how to merge partitions back.
-   *  <p>
-   *  <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>
+   * Creates a constant of {@code String} elements that is a copy of a given n-dimensional array,
+   *  using the default UTF-8 encoding.
    *
-   * @param <T> data type for {@code outputs()} output
-   * @param data
-   * @param partitions Any shape.  Indices in the range `[0, num_partitions)`.
-   * @param numPartitions The number of partitions to output.
-   * @return a new instance of DynamicPartition
+   * @param scope is a scope used to add the underlying operation.
+   * @param data an n-dimensional array of {@code String} elements.
+   * @return a string constant
    */
-  public <T extends TType> DynamicPartition<T> dynamicPartition(Operand<T> data,
-      Operand<TInt32> partitions, Long numPartitions) {
-    return DynamicPartition.create(scope, data, partitions, numPartitions);
+  public Constant<TString> constant(NdArray<String> data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Interleave the values from the `data` tensors into a single tensor.
-   *  <p>
-   *  Builds a merged tensor such that
-   *  <pre>{@code
-   *      merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]
-   *  }</pre>
-   *  For example, if each `indices[m]` is scalar or vector, we have
-   *  <pre>{@code
-   *      # Scalar indices:
-   *      merged[indices[m], ...] = data[m][...]
-   *
-   *      # Vector indices:
-   *      merged[indices[m][i], ...] = data[m][i, ...]
-   *  }</pre>
-   *  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
-   *  <p>
-   *      merged.shape = [max(indices)] + constant
-   *  <p>
-   *  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.
-   *  <p>
-   *  For example:
-   *  <pre>{@code
-   *      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]]
-   *  }</pre>
-   *  This method can be used to merge partitions created by `dynamic_partition`
-   *  as illustrated on the following example:
-   *  <pre>{@code
-   *      # 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.
-   *  }</pre>
-   *  <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>
+   * Creates a constant containing a single {@code byte} element.
    *
-   * @param <T> data type for {@code merged()} output
-   * @param indices
-   * @param data
-   * @return a new instance of DynamicStitch
+   * @param scope is a scope used to add the underlying operation.
+   * @param data The value to put into the new constant.
+   * @return a byte constant
    */
-  public <T extends TType> DynamicStitch<T> dynamicStitch(Iterable<Operand<TInt32>> indices,
-      Iterable<Operand<T>> data) {
-    return DynamicStitch.create(scope, indices, data);
+  public Constant<TUint8> constant(byte data) {
+    return Constant.scalarOf(scope, data);
   }
 
   /**
-   * Computes the (possibly normalized) Levenshtein Edit Distance.
-   *  <p>
-   *  The inputs are variable-length sequences provided by SparseTensors
-   *    (hypothesis_indices, hypothesis_values, hypothesis_shape)
-   *  and
-   *    (truth_indices, truth_values, truth_shape).
-   *  <p>
-   *  The inputs are:
+   * Creates a constant of {@code double} elements that is a copy of a given n-dimensional array.
    *
-   * @param hypothesisIndices The indices of the hypothesis list SparseTensor.
-   *  This is an N x R int64 matrix.
-   * @param hypothesisValues The values of the hypothesis list SparseTensor.
-   *  This is an N-length vector.
-   * @param hypothesisShape The shape of the hypothesis list SparseTensor.
-   *  This is an R-length vector.
-   * @param truthIndices The indices of the truth list SparseTensor.
-   *  This is an M x R int64 matrix.
-   * @param truthValues The values of the truth list SparseTensor.
-   *  This is an M-length vector.
-   * @param truthShape truth indices, vector.
-   * @param options carries optional attributes values
-   * @return a new instance of EditDistance
+   * @param scope is a scope used to add the underlying operation.
+   * @param data an n-dimensional array of {@code double} elements.
+   * @return a double constant
    */
-  public <T extends TType> EditDistance editDistance(Operand<TInt64> hypothesisIndices,
-      Operand<T> hypothesisValues, Operand<TInt64> hypothesisShape, Operand<TInt64> truthIndices,
-      Operand<T> truthValues, Operand<TInt64> truthShape, EditDistance.Options... options) {
-    return EditDistance.create(scope, hypothesisIndices, hypothesisValues, hypothesisShape, truthIndices, truthValues, truthShape, options);
+  public Constant<TFloat64> constant(DoubleNdArray data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Creates a tensor with the given shape.
-   *  <p>
-   *  This operation creates a tensor of `shape` and `dtype`.
+   * Creates a rank-3 constant of {@code boolean} elements.
    *
-   * @param <T> data type for {@code output()} output
-   * @param shape 1-D. Represents the shape of the output tensor.
-   * @param dtype
-   * @param options carries optional attributes values
-   * @return a new instance of Empty
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a boolean constant
    */
-  public <T extends TType> Empty<T> empty(Operand<TInt32> shape, DataType<T> dtype,
-      Empty.Options... options) {
-    return Empty.create(scope, shape, dtype, options);
+  public Constant<TBool> constant(boolean[][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Creates and returns an empty tensor list.
-   *  <p>
-   *  All list elements must be tensors of dtype element_dtype and shape compatible
-   *  with element_shape.
-   *  <p>
-   *  handle: an empty tensor list.
-   *  element_dtype: the type of elements in the list.
-   *  element_shape: a shape compatible with that of elements in the list.
+   * Creates a rank-4 constant of {@code float} elements.
    *
-   * @param elementShape
-   * @param maxNumElements
-   * @param elementDtype
-   * @return a new instance of EmptyTensorList
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a float constant
    */
-  public <T extends TNumber, U extends TType> EmptyTensorList emptyTensorList(
-      Operand<T> elementShape, Operand<TInt32> maxNumElements, DataType<U> elementDtype) {
-    return EmptyTensorList.create(scope, elementShape, maxNumElements, elementDtype);
+  public Constant<TFloat32> constant(float[][][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Ensures that the tensor's shape matches the expected shape.
-   *  <p>
-   *  Raises an error if the input tensor's shape does not match the specified shape.
-   *  Returns the input tensor otherwise.
+   * Creates a rank-2 constant of {@code long} elements.
    *
-   * @param <T> data type for {@code output()} output
-   * @param input A tensor, whose shape is to be validated.
-   * @param shape The expected (possibly partially specified) shape of the input tensor.
-   * @return a new instance of EnsureShape
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a long constant
    */
-  public <T extends TType> EnsureShape<T> ensureShape(Operand<T> input, Shape shape) {
-    return EnsureShape.create(scope, input, shape);
+  public Constant<TInt64> constant(long[][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Inserts a dimension of 1 into a tensor's shape.
-   *  <p>
-   *  Given a tensor `input`, this operation inserts a dimension of 1 at the
-   *  dimension index `axis` of `input`'s shape. The dimension index `axis` starts at
-   *  zero; if you specify a negative number for `axis` it is counted backward from
-   *  the end.
-   *  <p>
-   *  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]`.
-   *  <p>
-   *  Other examples:
-   *  <pre>{@code
-   *  # '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]
-   *  }</pre>
-   *  This operation requires that:
-   *  <p>
-   *  `-1-input.dims() <= dim <= input.dims()`
-   *  <p>
-   *  This operation is related to `squeeze()`, which removes dimensions of
-   *  size 1.
+   * Creates a constant of {@code long} elements that is a copy of a given n-dimensional array.
    *
-   * @param <T> data type for {@code output()} output
-   * @param input
-   * @param axis 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)]`.
-   * @return a new instance of ExpandDims
+   * @param scope is a scope used to add the underlying operation.
+   * @param data an n-dimensional array of {@code long} elements.
+   * @return a long constant
    */
-  public <T extends TType, U extends TNumber> ExpandDims<T> expandDims(Operand<T> input,
-      Operand<U> axis) {
-    return ExpandDims.create(scope, input, axis);
+  public Constant<TInt64> constant(LongNdArray data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Extract `patches` from `input` and put them in the "depth" output dimension. 3D extension of `extract_image_patches`.
+   * Creates a rank-5 constant of {@code byte} elements.
    *
-   * @param <T> data type for {@code patches()} output
-   * @param input 5-D Tensor with shape `[batch, in_planes, in_rows, in_cols, depth]`.
-   * @param ksizes The size of the sliding window for each dimension of `input`.
-   * @param strides 1-D of length 5. How far the centers of two consecutive patches are in
-   *  `input`. Must be: `[1, stride_planes, stride_rows, stride_cols, 1]`.
-   * @param padding The type of padding algorithm to use.
-   *  <p>
-   *  We specify the size-related attributes as:
-   *  <pre>{@code
-   *        ksizes = [1, ksize_planes, ksize_rows, ksize_cols, 1]
-   *        strides = [1, stride_planes, strides_rows, strides_cols, 1]
-   *  }</pre>
-   * @return a new instance of ExtractVolumePatches
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a byte constant
    */
-  public <T extends TNumber> ExtractVolumePatches<T> extractVolumePatches(Operand<T> input,
-      List<Long> ksizes, List<Long> strides, String padding) {
-    return ExtractVolumePatches.create(scope, input, ksizes, strides, padding);
+  public Constant<TUint8> constant(byte[][][][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Creates a tensor filled with a scalar value.
-   *  <p>
-   *  This operation creates a tensor of shape `dims` and fills it with `value`.
-   *  <p>
-   *  For example:
-   *  <pre>{@code
-   *  # Output tensor has shape [2, 3].
-   *  fill([2, 3], 9) ==> [[9, 9, 9]
-   *                       [9, 9, 9]]
-   *  }</pre>
-   *  `tf.fill` differs from `tf.constant` in a few ways:
-   *  <ul>
-   *  <li>
-   *  `tf.fill` only supports scalar contents, whereas `tf.constant` supports
-   *      Tensor values.
-   *  </li>
-   *  <li>
-   *  `tf.fill` creates an Op in the computation graph that constructs the actual
-   *      Tensor value at runtime. This is in contrast to `tf.constant` which embeds
-   *      the entire Tensor into the graph with a `Const` node.
-   *  </li>
-   *  <li>
-   *  Because `tf.fill` evaluates at graph runtime, it supports dynamic shapes
-   *      based on other runtime Tensors, unlike `tf.constant`.
+   * Creates a rank-2 constant of {@code float} elements.
    *
-   * @param <U> data type for {@code output()} output
-   * @param dims 1-D. Represents the shape of the output tensor.
-   * @param value 0-D (scalar). Value to fill the returned tensor.
-   *  <p>
-   * @compatibility(numpy) Equivalent to np.full
-   * @end_compatibility
-   * @return a new instance of Fill
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a float constant
    */
-  public <U extends TType, T extends TNumber> Fill<U> fill(Operand<T> dims, Operand<U> value) {
-    return Fill.create(scope, dims, value);
+  public Constant<TFloat32> constant(float[][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Generates fingerprint values.
-   *  <p>
-   *  Generates fingerprint values of `data`.
-   *  <p>
-   *  Fingerprint op considers the first dimension of `data` as the batch dimension,
-   *  and `output[i]` contains the fingerprint value generated from contents in
-   *  `data[i, ...]` for all `i`.
-   *  <p>
-   *  Fingerprint op writes fingerprint values as byte arrays. For example, the
-   *  default method `farmhash64` generates a 64-bit fingerprint value at a time.
-   *  This 8-byte value is written out as an `uint8` array of size 8, in little-endian
-   *  order.
-   *  <p>
-   *  For example, suppose that `data` has data type `DT_INT32` and shape (2, 3, 4),
-   *  and that the fingerprint method is `farmhash64`. In this case, the output shape
-   *  is (2, 8), where 2 is the batch dimension size of `data`, and 8 is the size of
-   *  each fingerprint value in bytes. `output[0, :]` is generated from 12 integers in
-   *  `data[0, :, :]` and similarly `output[1, :]` is generated from other 12 integers
-   *  in `data[1, :, :]`.
-   *  <p>
-   *  Note that this op fingerprints the raw underlying buffer, and it does not
-   *  fingerprint Tensor's metadata such as data type and/or shape. For example, the
-   *  fingerprint values are invariant under reshapes and bitcasts as long as the
-   *  batch dimension remain the same:
-   *  <pre>{@code
-   *  Fingerprint(data) == Fingerprint(Reshape(data, ...))
-   *  Fingerprint(data) == Fingerprint(Bitcast(data, ...))
-   *  }</pre>
-   *  For string data, one should expect `Fingerprint(data) !=
-   *  Fingerprint(ReduceJoin(data))` in general.
+   * Creates a rank-2 constant of {@code byte} elements.
    *
-   * @param data Must have rank 1 or higher.
-   * @param method Fingerprint method used by this op. Currently available method is
-   *  `farmhash::fingerprint64`.
-   * @return a new instance of Fingerprint
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a byte constant
    */
-  public <T extends TType> Fingerprint fingerprint(Operand<T> data, Operand<TString> method) {
-    return Fingerprint.create(scope, data, method);
+  public Constant<TUint8> constant(byte[][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Gather slices from `params` axis `axis` according to `indices`.
-   *  <p>
-   *  `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:
-   *  <pre>{@code
-   *      # 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]
+   * Creates a rank-5 constant of {@code double} elements.
    *
-   *      # 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]
-   *  }</pre>
-   *  <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>
-   *  <p>
-   *  Note that on CPU, if an out of bound index is found, an error is returned.
-   *  On GPU, if an out of bound index is found, a 0 is stored in the
-   *  corresponding output value.
-   *  <p>
-   *  See also `tf.batch_gather` and `tf.gather_nd`.
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a double constant
+   */
+  public Constant<TFloat64> constant(double[][][][][] data) {
+    return Constant.tensorOf(scope, data);
+  }
+
+  /**
+   * Creates a rank-3 constant of {@code float} elements.
    *
-   * @param <T> data type for {@code output()} output
-   * @param params The tensor from which to gather values. Must be at least rank
-   *  `axis + 1`.
-   * @param indices Index tensor. Must be in range `[0, params.shape[axis])`.
-   * @param axis The axis in `params` to gather `indices` from. Defaults to the first
-   *  dimension. Supports negative indexes.
-   * @param options carries optional attributes values
-   * @return a new instance of Gather
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a float constant
    */
-  public <T extends TType, U extends TNumber, V extends TNumber> Gather<T> gather(Operand<T> params,
-      Operand<U> indices, Operand<V> axis, Gather.Options... options) {
-    return Gather.create(scope, params, indices, axis, options);
+  public Constant<TFloat32> constant(float[][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Gather slices from `params` into a Tensor with shape specified by `indices`.
-   *  <p>
-   *  `indices` is a 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`:
-   *  <p>
-   *      output[\\(i_0, ..., i_{K-2}\\)] = params[indices[\\(i_0, ..., i_{K-2}\\)]]
-   *  <p>
-   *  Whereas in `tf.gather` `indices` defines slices into the `axis`
-   *  dimension of `params`, in `tf.gather_nd`, `indices` defines slices into the
-   *  first `N` dimensions of `params`, where `N = indices.shape[-1]`.
-   *  <p>
-   *  The last dimension of `indices` can be at most the rank of
-   *  `params`:
-   *  <p>
-   *      indices.shape[-1] <= params.rank
-   *  <p>
-   *  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
-   *  <p>
-   *      indices.shape[:-1] + params.shape[indices.shape[-1]:]
-   *  <p>
-   *  Note that on CPU, if an out of bound index is found, an error is returned.
-   *  On GPU, if an out of bound index is found, a 0 is stored in the
-   *  corresponding output value.
-   *  <p>
-   *  Some examples below.
-   *  <p>
-   *  Simple indexing into a matrix:
-   *  <pre>{@code
-   *      indices = [[0, 0], [1, 1]]
-   *      params = [['a', 'b'], ['c', 'd']]
-   *      output = ['a', 'd']
-   *  }</pre>
-   *  Slice indexing into a matrix:
-   *  <pre>{@code
-   *      indices = [[1], [0]]
-   *      params = [['a', 'b'], ['c', 'd']]
-   *      output = [['c', 'd'], ['a', 'b']]
-   *  }</pre>
-   *  Indexing into a 3-tensor:
-   *  <pre>{@code
-   *      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']
-   *  }</pre>
-   *  Batched indexing into a matrix:
-   *  <pre>{@code
-   *      indices = [[[0, 0]], [[0, 1]]]
-   *      params = [['a', 'b'], ['c', 'd']]
-   *      output = [['a'], ['b']]
-   *  }</pre>
-   *  Batched slice indexing into a matrix:
-   *  <pre>{@code
-   *      indices = [[[1]], [[0]]]
-   *      params = [['a', 'b'], ['c', 'd']]
-   *      output = [[['c', 'd']], [['a', 'b']]]
-   *  }</pre>
-   *  Batched indexing into a 3-tensor:
-   *  <pre>{@code
-   *      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']]
-   *  }</pre>
-   *  See also `tf.gather` and `tf.batch_gather`.
+   * Creates a rank-1 constant of {@code byte} elements.
    *
-   * @param <T> data type for {@code output()} output
-   * @param params The tensor from which to gather values.
-   * @param indices Index tensor.
-   * @return a new instance of GatherNd
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a byte constant
    */
-  public <T extends TType, U extends TNumber> GatherNd<T> gatherNd(Operand<T> params,
-      Operand<U> indices) {
-    return GatherNd.create(scope, params, indices);
+  public Constant<TUint8> constant(byte[] data) {
+    return Constant.vectorOf(scope, data);
   }
 
   /**
-   * Store the input tensor in the state of the current session.
+   * Creates a rank-1 constant of {@code float} elements.
    *
-   * @param value The tensor to be stored.
-   * @return a new instance of GetSessionHandle
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a float constant
    */
-  public <T extends TType> GetSessionHandle getSessionHandle(Operand<T> value) {
-    return GetSessionHandle.create(scope, value);
+  public Constant<TFloat32> constant(float[] data) {
+    return Constant.vectorOf(scope, data);
   }
 
   /**
-   * Get the value of the tensor specified by its handle.
+   * Creates a rank-2 constant of {@code boolean} elements.
    *
-   * @param <T> data type for {@code value()} output
-   * @param handle The handle for a tensor stored in the session state.
-   * @param dtype The type of the output value.
-   * @return a new instance of GetSessionTensor
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a boolean constant
    */
-  public <T extends TType> GetSessionTensor<T> getSessionTensor(Operand<TString> handle,
-      DataType<T> dtype) {
-    return GetSessionTensor.create(scope, handle, dtype);
+  public Constant<TBool> constant(boolean[][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Adds gradients computation ops to the graph according to scope.
+   * Creates a constant of {@code byte} elements that is a copy of a given n-dimensional array.
    *
-   * @param scope current graph scope
-   * @param y outputs of the function to derive
-   * @param x inputs of the function for which partial derivatives are computed
-   * @param options carries optional attributes values
-   * @return a new instance of {@code Gradients}
-   * @throws IllegalArgumentException if execution environment is not a graph
+   * @param scope is a scope used to add the underlying operation.
+   * @param data an n-dimensional array of {@code byte} elements.
+   * @return a byte constant
    */
-  public Gradients gradients(Iterable<? extends Operand<?>> y, Iterable<? extends Operand<?>> x,
-      Gradients.Options... options) {
-    return Gradients.create(scope, y, x, options);
+  public Constant<TUint8> constant(ByteNdArray data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Adds operations to compute the partial derivatives of sum of {@code y}s w.r.t {@code x}s,
-   *  i.e., {@code d(y_1 + y_2 + ...)/dx_1, d(y_1 + y_2 + ...)/dx_2...}
-   *  <p> 
-   *  If {@code Options.dx()} values are set, they are as the initial symbolic partial derivatives of some loss 
-   *  function {@code L} w.r.t. {@code y}. {@code Options.dx()} must have the size of {@code y}.
-   *  <p>
-   *  If {@code Options.dx()} is not set, the implementation will use dx of {@code OnesLike} for all
-   *  shapes in {@code y}.
-   *  <p>
-   *  The partial derivatives are returned in output {@code dy}, with the size of {@code x}.
-   *  <p>
-   *  Example of usage:
-   *  <pre>{@code
-   *  Gradients gradients = tf.gradients(loss, Arrays.asList(w, b));
-   *  Constant<TFloat32> alpha = tf.val(1.0f);
-   *  tf.train.applyGradientDescent(w, alpha, gradients.<Float>dy(0));
-   *  tf.train.applyGradientDescent(b, alpha, gradients.<Float>dy(1));
-   *  }</pre>
+   * Creates a constant of {@code int} elements that is a copy of a given n-dimensional array.
    *
-   * @param y output of the function to derive
-   * @param x inputs of the function for which partial derivatives are computed
-   * @param options carries optional attributes values
-   * @return a new instance of {@code Gradients}
-   * @throws IllegalArgumentException if execution environment is not a graph
+   * @param scope is a scope used to add the underlying operation.
+   * @param data an n-dimensional array of {@code int} elements.
+   * @return an integer constant
    */
-  public Gradients gradients(Operand<?> y, Iterable<? extends Operand<?>> x,
-      Gradients.Options... options) {
-    return Gradients.create(scope, y, x, options);
+  public Constant<TInt32> constant(IntNdArray data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Gives a guarantee to the TF runtime that the input tensor is a constant.
-   *  <p>
-   *  The runtime is then free to make optimizations based on this.
-   *  <p>
-   *  Only accepts value typed tensors as inputs and rejects resource variable handles
-   *  as input.
-   *  <p>
-   *  Returns the input tensor without modification.
+   * Creates a {@code String} constant using the default, UTF-8 encoding.
    *
-   * @param <T> data type for {@code output()} output
-   * @param input
-   * @return a new instance of GuaranteeConst
+   * @param scope is a scope used to add the underlying operation.
+   * @param data The string to put into the new constant.
+   * @return a string constant
    */
-  public <T extends TType> GuaranteeConst<T> guaranteeConst(Operand<T> input) {
-    return GuaranteeConst.create(scope, input);
+  public Constant<TString> constant(String data) {
+    return Constant.scalarOf(scope, data);
   }
 
   /**
-   * Creates a non-initialized hash table.
-   *  <p>
-   *  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.
+   * Creates a rank-4 constant of {@code double} elements.
    *
-   * @param keyDtype Type of the table keys.
-   * @param valueDtype Type of the table values.
-   * @param options carries optional attributes values
-   * @return a new instance of HashTable
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a double constant
    */
-  public <T extends TType, U extends TType> HashTable hashTable(DataType<T> keyDtype,
-      DataType<U> valueDtype, HashTable.Options... options) {
-    return HashTable.create(scope, keyDtype, valueDtype, options);
+  public Constant<TFloat64> constant(double[][][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Return histogram of values.
-   *  <p>
-   *  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`.
-   *  <pre>{@code
-   *  # 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]
-   *  }</pre>
+   * Creates a rank-2 constant of {@code double} elements.
    *
-   * @param <U> data type for {@code out()} output
-   * @param values Numeric `Tensor`.
-   * @param valueRange 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].
-   * @param nbins Scalar `int32 Tensor`.  Number of histogram bins.
-   * @return a new instance of HistogramFixedWidth
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a double constant
    */
-  public <T extends TNumber> HistogramFixedWidth<TInt32> histogramFixedWidth(Operand<T> values,
-      Operand<T> valueRange, Operand<TInt32> nbins) {
-    return HistogramFixedWidth.create(scope, values, valueRange, nbins);
+  public Constant<TFloat64> constant(double[][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Return histogram of values.
-   *  <p>
-   *  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`.
-   *  <pre>{@code
-   *  # 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]
+   * Creates a constant containing a single {@code int} element.
    *
-   *  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]
-   *  }</pre>
-   *
-   * @param <U> data type for {@code out()} output
-   * @param values Numeric `Tensor`.
-   * @param valueRange 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].
-   * @param nbins Scalar `int32 Tensor`.  Number of histogram bins.
-   * @param dtype
-   * @return a new instance of HistogramFixedWidth
+   * @param scope is a scope used to add the underlying operation.
+   * @param data The value to put into the new constant.
+   * @return an integer constant
    */
-  public <U extends TNumber, T extends TNumber> HistogramFixedWidth<U> histogramFixedWidth(
-      Operand<T> values, Operand<T> valueRange, Operand<TInt32> nbins, DataType<U> dtype) {
-    return HistogramFixedWidth.create(scope, values, valueRange, nbins, dtype);
+  public Constant<TInt32> constant(int data) {
+    return Constant.scalarOf(scope, data);
   }
 
   /**
-   * Return a tensor with the same shape and contents as the input tensor or value.
+   * Creates a rank-4 constant of {@code byte} elements.
    *
-   * @param <T> data type for {@code output()} output
-   * @param input
-   * @return a new instance of Identity
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a byte constant
    */
-  public <T extends TType> Identity<T> identity(Operand<T> input) {
-    return Identity.create(scope, input);
+  public Constant<TUint8> constant(byte[][][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Returns a list of tensors with the same shapes and contents as the input
-   *  <p>
-   *  tensors.
-   *  <p>
-   *  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,
-   *  <pre>{@code
-   *  with tf.get_default_graph().gradient_override_map(
-   *      {'IdentityN': 'OverrideGradientWithG'}):
-   *    y, _ = identity_n([f(x), x])
+   * Creates a rank-6 constant of {@code int} elements.
    *
-   * @tf.RegisterGradient('OverrideGradientWithG') def ApplyG(op, dy, _):
-   *    return [None, g(dy)]  # Do not backprop to f(x).
-   *  }</pre>
-   * @param input
-   * @return a new instance of IdentityN
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return an integer constant
    */
-  public IdentityN identityN(Iterable<Operand<?>> input) {
-    return IdentityN.create(scope, input);
+  public Constant<TInt32> constant(int[][][][][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Returns immutable tensor from memory region.
-   *  <p>
-   *  The current implementation memmaps the tensor from a file.
+   * Creates a constant containing a single {@code long} element.
    *
-   * @param <T> data type for {@code tensor()} output
-   * @param dtype Type of the returned tensor.
-   * @param shape Shape of the returned tensor.
-   * @param memoryRegionName Name of readonly memory region used by the tensor, see
-   *  NewReadOnlyMemoryRegionFromFile in tensorflow::Env.
-   * @return a new instance of ImmutableConst
+   * @param scope is a scope used to add the underlying operation.
+   * @param data The value to put into the new constant.
+   * @return a long constant
    */
-  public <T extends TType> ImmutableConst<T> immutableConst(DataType<T> dtype, Shape shape,
-      String memoryRegionName) {
-    return ImmutableConst.create(scope, dtype, shape, memoryRegionName);
+  public Constant<TInt64> constant(long data) {
+    return Constant.scalarOf(scope, data);
   }
 
   /**
-   * Table initializer that takes two tensors for keys and values respectively.
+   * Creates a constant containing a single {@code float} element.
    *
-   * @param tableHandle Handle to a table which will be initialized.
-   * @param keys Keys of type Tkey.
-   * @param values Values of type Tval.
-   * @return a new instance of InitializeTable
+   * @param scope is a scope used to add the underlying operation.
+   * @param data The value to put into the new constant.
+   * @return a float constant
    */
-  public <T extends TType, U extends TType> InitializeTable initializeTable(Operand<?> tableHandle,
-      Operand<T> keys, Operand<U> values) {
-    return InitializeTable.create(scope, tableHandle, keys, values);
+  public Constant<TFloat32> constant(float data) {
+    return Constant.scalarOf(scope, data);
   }
 
   /**
-   * Initializes a table from a text file.
-   *  <p>
-   *  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`.
-   *  <p>
-   *  - 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`.
+   * Creates a rank-5 constant of {@code float} elements.
    *
-   * @param tableHandle Handle to a table which will be initialized.
-   * @param filename Filename of a vocabulary text file.
-   * @param keyIndex Column index in a line to get the table `key` values from.
-   * @param valueIndex Column index that represents information of a line to get the table
-   *  `value` values from.
-   * @param options carries optional attributes values
-   * @return a new instance of InitializeTableFromTextFile
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a float constant
    */
-  public InitializeTableFromTextFile initializeTableFromTextFile(Operand<?> tableHandle,
-      Operand<TString> filename, Long keyIndex, Long valueIndex,
-      InitializeTableFromTextFile.Options... options) {
-    return InitializeTableFromTextFile.create(scope, tableHandle, filename, keyIndex, valueIndex, options);
+  public Constant<TFloat32> constant(float[][][][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   *     Adds v into specified rows of x.
-   *  <p>
-   *      Computes y = x; y[i, :] += v; return y.
+   * Creates a rank-3 constant of {@code double} elements.
    *
-   * @param <T> data type for {@code y()} output
-   * @param x A `Tensor` of type T.
-   * @param i A vector. Indices into the left-most dimension of `x`.
-   * @param v A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
-   * @return a new instance of InplaceAdd
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a double constant
    */
-  public <T extends TType> InplaceAdd<T> inplaceAdd(Operand<T> x, Operand<TInt32> i, Operand<T> v) {
-    return InplaceAdd.create(scope, x, i, v);
+  public Constant<TFloat64> constant(double[][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   *     Subtracts `v` into specified rows of `x`.
-   *  <p>
-   *      Computes y = x; y[i, :] -= v; return y.
+   * Creates a rank-6 constant of {@code long} elements.
    *
-   * @param <T> data type for {@code y()} output
-   * @param x A `Tensor` of type T.
-   * @param i A vector. Indices into the left-most dimension of `x`.
-   * @param v A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
-   * @return a new instance of InplaceSub
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a long constant
    */
-  public <T extends TType> InplaceSub<T> inplaceSub(Operand<T> x, Operand<TInt32> i, Operand<T> v) {
-    return InplaceSub.create(scope, x, i, v);
+  public Constant<TInt64> constant(long[][][][][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   *     Updates specified rows with values in `v`.
-   *  <p>
-   *      Computes `x[i, :] = v; return x`.
+   * Creates a rank-4 constant of {@code long} elements.
    *
-   * @param <T> data type for {@code y()} output
-   * @param x A tensor of type `T`.
-   * @param i A vector. Indices into the left-most dimension of `x`.
-   * @param v A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
-   * @return a new instance of InplaceUpdate
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a long constant
    */
-  public <T extends TType> InplaceUpdate<T> inplaceUpdate(Operand<T> x, Operand<TInt32> i,
-      Operand<T> v) {
-    return InplaceUpdate.create(scope, x, i, v);
+  public Constant<TInt64> constant(long[][][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Checks whether a tensor has been initialized.
-   *  <p>
-   *  Outputs boolean scalar indicating whether the tensor has been initialized.
+   * Creates a rank-1 constant of {@code long} elements.
    *
-   * @param ref Should be from a `Variable` node. May be uninitialized.
-   * @return a new instance of IsVariableInitialized
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a long constant
    */
-  public <T extends TType> IsVariableInitialized isVariableInitialized(Operand<T> ref) {
-    return IsVariableInitialized.create(scope, ref);
+  public Constant<TInt64> constant(long[] data) {
+    return Constant.vectorOf(scope, data);
   }
 
   /**
-   * Generates values in an interval.
-   *  <p>
-   *  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`.
-   *  <p>
-   *  For example:
-   *  <pre>{@code
-   *  tf.linspace(10.0, 12.0, 3, name="linspace") => [ 10.0  11.0  12.0]
-   *  }</pre>
+   * Creates a rank-1 constant of {@code boolean} elements.
    *
-   * @param <T> data type for {@code output()} output
-   * @param start 0-D tensor. First entry in the range.
-   * @param stop 0-D tensor. Last entry in the range.
-   * @param num 0-D tensor. Number of values to generate.
-   * @return a new instance of LinSpace
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a boolean constant
    */
-  public <T extends TNumber, U extends TNumber> LinSpace<T> linSpace(Operand<T> start,
-      Operand<T> stop, Operand<U> num) {
-    return LinSpace.create(scope, start, stop, num);
+  public Constant<TBool> constant(boolean[] data) {
+    return Constant.vectorOf(scope, data);
   }
 
   /**
-   * Outputs all keys and values in the table.
+   * Creates a rank-3 constant of {@code byte} elements.
    *
-   * @param <T> data type for {@code keys()} output
-   * @param <U> data type for {@code values()} output
-   * @param tableHandle Handle to the table.
-   * @param Tkeys
-   * @param Tvalues
-   * @return a new instance of LookupTableExport
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a byte constant
    */
-  public <T extends TType, U extends TType> LookupTableExport<T, U> lookupTableExport(
-      Operand<?> tableHandle, DataType<T> Tkeys, DataType<U> Tvalues) {
-    return LookupTableExport.create(scope, tableHandle, Tkeys, Tvalues);
+  public Constant<TUint8> constant(byte[][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Looks up keys in a table, outputs the corresponding values.
-   *  <p>
-   *  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.
-   *  <p>
-   *  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.
+   * Creates a rank-6 constant of {@code byte} elements.
    *
-   * @param <U> data type for {@code values()} output
-   * @param tableHandle Handle to the table.
-   * @param keys Any shape.  Keys to look up.
-   * @param defaultValue
-   * @return a new instance of LookupTableFind
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a byte constant
    */
-  public <U extends TType, T extends TType> LookupTableFind<U> lookupTableFind(
-      Operand<?> tableHandle, Operand<T> keys, Operand<U> defaultValue) {
-    return LookupTableFind.create(scope, tableHandle, keys, defaultValue);
+  public Constant<TUint8> constant(byte[][][][][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Replaces the contents of the table with the specified keys and values.
-   *  <p>
-   *  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.
+   * Creates a rank-2 constant of {@code int} elements.
    *
-   * @param tableHandle Handle to the table.
-   * @param keys Any shape.  Keys to look up.
-   * @param values Values to associate with keys.
-   * @return a new instance of LookupTableImport
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return an integer constant
    */
-  public <T extends TType, U extends TType> LookupTableImport lookupTableImport(
-      Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
-    return LookupTableImport.create(scope, tableHandle, keys, values);
+  public Constant<TInt32> constant(int[][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Updates the table to associates keys with values.
-   *  <p>
-   *  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.
+   * Creates a rank-5 constant of {@code int} elements.
    *
-   * @param tableHandle Handle to the table.
-   * @param keys Any shape.  Keys to look up.
-   * @param values Values to associate with keys.
-   * @return a new instance of LookupTableInsert
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return an integer constant
    */
-  public <T extends TType, U extends TType> LookupTableInsert lookupTableInsert(
-      Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
-    return LookupTableInsert.create(scope, tableHandle, keys, values);
+  public Constant<TInt32> constant(int[][][][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Computes the number of elements in the given table.
+   * Creates a constant of {@code float} elements that is a copy of a given n-dimensional array.
    *
-   * @param tableHandle Handle to the table.
-   * @return a new instance of LookupTableSize
+   * @param scope is a scope used to add the underlying operation.
+   * @param data an n-dimensional array of {@code float} elements.
+   * @return a float constant
    */
-  public LookupTableSize lookupTableSize(Operand<?> tableHandle) {
-    return LookupTableSize.create(scope, tableHandle);
+  public Constant<TFloat32> constant(FloatNdArray data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Forwards the input to the output.
-   *  <p>
-   *  This operator represents the loop termination condition used by the
-   *  "pivot" switches of a loop.
+   * Creates a rank-1 constant of {@code double} elements.
    *
-   * @param input A boolean scalar, representing the branch predicate of the Switch op.
-   * @return a new instance of LoopCond
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a double constant
    */
-  public LoopCond loopCond(Operand<TBool> input) {
-    return LoopCond.create(scope, input);
+  public Constant<TFloat64> constant(double[] data) {
+    return Constant.vectorOf(scope, data);
   }
 
   /**
-   * Op removes all elements in the underlying container.
+   * Creates a rank-6 constant of {@code boolean} elements.
    *
-   * @param dtypes
-   * @param options carries optional attributes values
-   * @return a new instance of MapClear
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a boolean constant
    */
-  public MapClear mapClear(List<DataType<?>> dtypes, MapClear.Options... options) {
-    return MapClear.create(scope, dtypes, options);
+  public Constant<TBool> constant(boolean[][][][][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Op returns the number of incomplete elements in the underlying container.
+   * Creates a rank-6 constant of {@code double} elements.
    *
-   * @param dtypes
-   * @param options carries optional attributes values
-   * @return a new instance of MapIncompleteSize
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a double constant
    */
-  public MapIncompleteSize mapIncompleteSize(List<DataType<?>> dtypes,
-      MapIncompleteSize.Options... options) {
-    return MapIncompleteSize.create(scope, dtypes, options);
+  public Constant<TFloat64> constant(double[][][][][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Op peeks at the values at the specified key.  If the
-   *  <p>
-   *  underlying container does not contain this key
-   *  this op will block until it does.
+   * Creates a constant containing a single {@code boolean} element.
    *
-   * @param key
-   * @param indices
-   * @param dtypes
-   * @param options carries optional attributes values
-   * @return a new instance of MapPeek
+   * @param scope is a scope used to add the underlying operation.
+   * @param data The value to put into the new constant.
+   * @return a boolean constant
    */
-  public MapPeek mapPeek(Operand<TInt64> key, Operand<TInt32> indices, List<DataType<?>> dtypes,
-      MapPeek.Options... options) {
-    return MapPeek.create(scope, key, indices, dtypes, options);
+  public Constant<TBool> constant(boolean data) {
+    return Constant.scalarOf(scope, data);
   }
 
   /**
-   * Op returns the number of elements in the underlying container.
+   * Creates a rank-4 constant of {@code boolean} elements.
    *
-   * @param dtypes
-   * @param options carries optional attributes values
-   * @return a new instance of MapSize
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a boolean constant
    */
-  public MapSize mapSize(List<DataType<?>> dtypes, MapSize.Options... options) {
-    return MapSize.create(scope, dtypes, options);
+  public Constant<TBool> constant(boolean[][][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Stage (key, values) in the underlying container which behaves like a hashtable.
+   * Creates a rank-3 constant of {@code long} elements.
    *
-   * @param key int64
-   * @param indices
-   * @param values a list of tensors
-   *  dtypes A list of data types that inserted values should adhere to.
-   * @param dtypes
-   * @param options carries optional attributes values
-   * @return a new instance of MapStage
+   * @param scope is a scope used to add the underlying operation.
+   * @param data An array containing the values to put into the new constant. The dimensions of the
+   *      new constant will match those of the array.
+   * @return a long constant
    */
-  public MapStage mapStage(Operand<TInt64> key, Operand<TInt32> indices,
-      Iterable<Operand<?>> values, List<DataType<?>> dtypes, MapStage.Options... options) {
-    return MapStage.create(scope, key, indices, values, dtypes, options);
+  public Constant<TInt64> constant(long[][][] data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Op removes and returns the values associated with the key
-   *  <p>
-   *  from the underlying container.   If the underlying container
-   *  does not contain this key, the op will block until it does.
+   * Creates a constant of {@code boolean} elements that is a copy of a given n-dimensional array.
    *
-   * @param key
-   * @param indices
-   * @param dtypes
-   * @param options carries optional attributes values
-   * @return a new instance of MapUnstage
+   * @param scope is a scope used to add the underlying operation.
+   * @param data an n-dimensional array of {@code boolean} elements.
+   * @return a boolean constant
    */
-  public MapUnstage mapUnstage(Operand<TInt64> key, Operand<TInt32> indices,
-      List<DataType<?>> dtypes, MapUnstage.Options... options) {
-    return MapUnstage.create(scope, key, indices, dtypes, options);
+  public Constant<TBool> constant(BooleanNdArray data) {
+    return Constant.tensorOf(scope, data);
   }
 
   /**
-   * Op removes and returns a random (key, value)
-   *  <p>
-   *  from the underlying container.   If the underlying container
-   *  does not contain elements, the op will block until it does.
+   * Creates a rank-1 constant of {@code long} elements representing the size of each dimensions of
+   *  the given shape.
    *
-   * @param indices
-   * @param dtypes
-   * @param options carries optional attributes values
-   * @return a new instance of MapUnstageNoKey
+   * @param scope is a scope used to add the underlying operation.
+   * @param shape a shape
+   * @return a long constant
    */
-  public MapUnstageNoKey mapUnstageNoKey(Operand<TInt32> indices, List<DataType<?>> dtypes,
-      MapUnstageNoKey.Options... options) {
-    return MapUnstageNoKey.create(scope, indices, dtypes, options);
+  public Constant<TInt64> constant(Shape shape) {
+    return Constant.tensorOf(scope, shape);
   }
 
   /**
-   * Computes the maximum of elements across dimensions of a tensor.
-   *  <p>
-   *  Reduces `input` 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 are
-   *  retained with length 1.
+   * Create a constant from a Tensor.
    *
-   * @param <T> data type for {@code output()} output
-   * @param input The tensor to reduce.
-   * @param axis The dimensions to reduce. Must be in the range
-   *  `[-rank(input), rank(input))`.
-   * @param options carries optional attributes values
-   * @return a new instance of Max
+   * @param scope is a scope used to add the underlying operation.
+   * @param tensor a Tensor holding the constant value
+   * @return a constant of the same data type as `tensor`
    */
-  public <T extends TType, U extends TNumber> Max<T> max(Operand<T> input, Operand<U> axis,
-      Max.Options... options) {
-    return Max.create(scope, input, axis, options);
+  public <T extends TType> Constant<T> constant(Tensor<T> tensor) {
+    return Constant.create(scope, tensor);
   }
 
   /**
-   * Forwards the value of an available tensor from `inputs` to `output`.
-   *  <p>
-   *  `Merge` waits for at least one of the tensors in `inputs` to become available.
-   *  It is usually combined with `Switch` to implement branching.
-   *  <p>
-   *  `Merge` forwards the first tensor to become available to `output`, and sets
-   *  `value_index` to its index in `inputs`.
+   * Creates a constant of {@code String} elements, using the given charset.
    *
-   * @param <T> data type for {@code output()} output
-   * @param inputs The input tensors, exactly one of which will become available.
-   * @return a new instance of Merge
+   * @param scope is a scope used to add the underlying operation.
+   * @param charset charset for encoding/decoding strings bytes.
+   * @param data An array containing the values to put into the new constant. String elements are
+   *      sequences of bytes from the last array dimension.
+   * @return the {@code String} constant
    */
-  public <T extends TType> Merge<T> merge(Iterable<Operand<T>> inputs) {
-    return Merge.create(scope, inputs);
+  public Constant<TString> constant(Charset charset, String[] data) {
+    return Constant.vectorOf(scope, charset, data);
   }
 
   /**
-   * Computes the minimum of elements across dimensions of a tensor.
-   *  <p>
-   *  Reduces `input` 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 are
-   *  retained with length 1.
+   * Creates a {@code String} constant using a specified encoding.
    *
-   * @param <T> data type for {@code output()} output
-   * @param input The tensor to reduce.
-   * @param axis The dimensions to reduce. Must be in the range
-   *  `[-rank(input), rank(input))`.
-   * @param options carries optional attributes values
-   * @return a new instance of Min
+   * @param scope is a scope used to add the underlying operation.
+   * @param charset The encoding from String to bytes.
+   * @param data The string to put into the new constant.
+   * @return a string constant
    */
-  public <T extends TType, U extends TNumber> Min<T> min(Operand<T> input, Operand<U> axis,
-      Min.Options... options) {
-    return Min.create(scope, input, axis, options);
+  public Constant<TString> constant(Charset charset, String data) {
+    return Constant.scalarOf(scope, charset, data);
   }
 
   /**
-   * Pads a tensor with mirrored values.
-   *  <p>
-   *  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).
-   *  <p>
-   *  The padded size of each dimension D of the output is:
-   *  <p>
-   *  `paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
-   *  <p>
-   *  For example:
-   *  <pre>{@code
-   *  # '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]]
-   *  }</pre>
+   * Creates a constant of {@code String} elements that is a copy of a given n-dimensional array,
+   *  using the given encoding.
    *
-   * @param <T> data type for {@code output()} output
-   * @param input The input tensor to be padded.
-   * @param paddings A two-column matrix specifying the padding sizes. The number of
-   *  rows must be the same as the rank of `input`.
-   * @param mode 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.
-   * @return a new instance of MirrorPad
+   * @param scope is a scope used to add the underlying operation.
+   * @param charset charset used to encode/decode string bytes.
+   * @param data an n-dimensional array of {@code String} elements.
+   * @return a string constant
    */
-  public <T extends TType, U extends TNumber> MirrorPad<T> mirrorPad(Operand<T> input,
-      Operand<U> paddings, String mode) {
-    return MirrorPad.create(scope, input, paddings, mode);
+  public Constant<TString> constant(Charset charset, NdArray<String> data) {
+    return Constant.tensorOf(scope, charset, data);
   }
 
   /**
-   * Wraps an arbitrary MLIR computation expressed as a module with a main() function.
-   *  <p>
-   *  This operation does not have an associated kernel and is not intended to be
-   *  executed in a regular TensorFlow session. Instead it is intended to be used for
-   *  testing or for special case where a user intends to pass custom MLIR computation
-   *  through a TensorFlow graph with the intent of having custom tooling processing
-   *  it downstream (when targeting a different environment, like TensorFlow lite for
-   *  example).
-   *  The MLIR module is expected to have a main() function that will be used as an
-   *  entry point. The inputs to the operations will be passed as argument to the
-   *  main() function and the returned values of the main function mapped to the
-   *  outputs.
-   *  Example usage:
-   *  <pre>{@code
-   *  import tensorflow as tf
-   *  from tensorflow.compiler.mlir.tensorflow.gen_mlir_passthrough_op import mlir_passthrough_op
-   *
-   *  mlir_module = '''python
-   *  func @main(%arg0 : tensor<10xf32>, %arg1 : tensor<10xf32>) -> tensor<10x10xf32> {
-   *     %add = "magic.op"(%arg0, %arg1) : (tensor<10xf32>, tensor<10xf32>) -> tensor<10x10xf32>
-   *     return %ret : tensor<10x10xf32>
-   *  }
-   *  '''
-   *
-   * @tf.function def foo(x, y):
-   *    return = mlir_passthrough_op([x, y], mlir_module, Toutputs=[tf.float32])
+   * Create a {@link TInt32} constant with data from the given buffer.
    *
-   *  graph_def = foo.get_concrete_function(tf.TensorSpec([10], tf.float32), tf.TensorSpec([10], tf.float32)).graph.as_graph_def()
-   *  }</pre>
-   * @param inputs
-   * @param mlirModule
-   * @param Toutputs
-   * @return a new instance of MlirPassthroughOp
+   * @param scope is a scope used to add the underlying operation.
+   * @param shape the tensor shape.
+   * @param data a buffer containing the tensor data.
+   * @return an integer constant
+   * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
    */
-  public MlirPassthroughOp mlirPassthroughOp(Iterable<Operand<?>> inputs, String mlirModule,
-      List<DataType<?>> Toutputs) {
-    return MlirPassthroughOp.create(scope, inputs, mlirModule, Toutputs);
+  public Constant<TInt32> constant(Shape shape, IntDataBuffer data) {
+    return Constant.tensorOf(scope, shape, data);
   }
 
   /**
-   * Creates an empty hash table that uses tensors as the backing store.
-   *  <p>
-   *  It uses "open addressing" with quadratic reprobing to resolve
-   *  collisions.
-   *  <p>
-   *  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.
+   * Create a {@link TFloat64} constant with data from the given buffer.
    *
-   * @param emptyKey The key used to represent empty key buckets internally. Must not
-   *  be used in insert or lookup operations.
-   * @param deletedKey
-   * @param valueDtype Type of the table values.
-   * @param options carries optional attributes values
-   * @return a new instance of MutableDenseHashTable
+   * @param scope is a scope used to add the underlying operation.
+   * @param shape the tensor shape.
+   * @param data a buffer containing the tensor data.
+   * @return a double constant
+   * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
    */
-  public <T extends TType, U extends TType> MutableDenseHashTable mutableDenseHashTable(
-      Operand<T> emptyKey, Operand<T> deletedKey, DataType<U> valueDtype,
-      MutableDenseHashTable.Options... options) {
-    return MutableDenseHashTable.create(scope, emptyKey, deletedKey, valueDtype, options);
+  public Constant<TFloat64> constant(Shape shape, DoubleDataBuffer data) {
+    return Constant.tensorOf(scope, shape, data);
   }
 
   /**
-   * Creates an empty hash table.
-   *  <p>
-   *  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.
+   * Create a {@link TBool} constant with data from the given buffer.
    *
-   * @param keyDtype Type of the table keys.
-   * @param valueDtype Type of the table values.
-   * @param options carries optional attributes values
-   * @return a new instance of MutableHashTable
+   * @param scope is a scope used to add the underlying operation.
+   * @param shape the tensor shape.
+   * @param data a buffer containing the tensor data.
+   * @return an boolean constant
+   * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
    */
-  public <T extends TType, U extends TType> MutableHashTable mutableHashTable(DataType<T> keyDtype,
-      DataType<U> valueDtype, MutableHashTable.Options... options) {
-    return MutableHashTable.create(scope, keyDtype, valueDtype, options);
+  public Constant<TBool> constant(Shape shape, BooleanDataBuffer data) {
+    return Constant.tensorOf(scope, shape, data);
   }
 
   /**
-   * Creates an empty hash table.
-   *  <p>
-   *  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.
+   * Create a {@link TFloat32} constant with data from the given buffer.
    *
-   * @param keyDtype Type of the table keys.
-   * @param valueDtype Type of the table values.
-   * @param options carries optional attributes values
-   * @return a new instance of MutableHashTableOfTensors
+   * @param scope is a scope used to add the underlying operation.
+   * @param shape the tensor shape.
+   * @param data a buffer containing the tensor data.
+   * @return a float constant
+   * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
    */
-  public <T extends TType, U extends TType> MutableHashTableOfTensors mutableHashTableOfTensors(
-      DataType<T> keyDtype, DataType<U> valueDtype, MutableHashTableOfTensors.Options... options) {
-    return MutableHashTableOfTensors.create(scope, keyDtype, valueDtype, options);
+  public Constant<TFloat32> constant(Shape shape, FloatDataBuffer data) {
+    return Constant.tensorOf(scope, shape, data);
   }
 
   /**
-   * Creates a Mutex resource that can be locked by `MutexLock`.
+   * Create a {@link TInt64} constant with data from the given buffer.
    *
-   * @param options carries optional attributes values
-   * @return a new instance of Mutex
+   * @param scope is a scope used to add the underlying operation.
+   * @param shape the tensor shape.
+   * @param data a buffer containing the tensor data.
+   * @return a long constant
+   * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
    */
-  public Mutex mutex(Mutex.Options... options) {
-    return Mutex.create(scope, options);
+  public Constant<TInt64> constant(Shape shape, LongDataBuffer data) {
+    return Constant.tensorOf(scope, shape, data);
   }
 
   /**
-   * Locks a mutex resource.  The output is the lock.  So long as the lock tensor
-   *  <p>
-   *  is alive, any other request to use `MutexLock` with this mutex will wait.
-   *  <p>
-   *  This is particularly useful for creating a critical section when used in
-   *  conjunction with `MutexLockIdentity`:
-   *  <pre>{@code
-   *  mutex = mutex_v2(
-   *    shared_name=handle_name, container=container, name=name)
-   *
-   *  def execute_in_critical_section(fn, *args, **kwargs):
-   *    lock = gen_resource_variable_ops.mutex_lock(mutex)
+   * Create a {@link TUint8} constant with data from the given buffer.
    *
-   *    with ops.control_dependencies([lock]):
-   *      r = fn(*args, **kwargs)
+   * @param scope is a scope used to add the underlying operation.
+   * @param shape the tensor shape.
+   * @param data a buffer containing the tensor data.
+   * @return a byte constant
+   * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
+   */
+  public Constant<TUint8> constant(Shape shape, ByteDataBuffer data) {
+    return Constant.tensorOf(scope, shape, data);
+  }
+
+  /**
+   * Create a {@link TString} constant with data from the given buffer, using the default UTF-8
+   *  encoding.
    *
-   *    with ops.control_dependencies(nest.flatten(r)):
-   *      with ops.colocate_with(mutex):
-   *        ensure_lock_exists = mutex_lock_identity(lock)
+   * @param scope is a scope used to add the underlying operation.
+   * @param shape the tensor shape.
+   * @param data a buffer containing the tensor data.
+   * @return a string constant
+   * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
+   */
+  public Constant<TString> constant(Shape shape, DataBuffer<String> data) {
+    return Constant.tensorOf(scope, shape, data);
+  }
+
+  /**
+   * Create a {@link TString} constant with data from the given buffer, using the given encoding.
    *
-   *      # Make sure that if any element of r is accessed, all of
-   *      # them are executed together.
-   *      r = nest.map_structure(tf.identity, r)
+   * @param scope is a scope used to add the underlying operation.
+   * @param charset charset used to encode/decode string bytes.
+   * @param shape the tensor shape.
+   * @param data a buffer containing the tensor data.
+   * @return a string constant
+   * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
+   */
+  public Constant<TString> constant(Charset charset, Shape shape, DataBuffer<String> data) {
+    return Constant.tensorOf(scope, charset, shape, data);
+  }
+
+  /**
+   * Create a constant with data from the given buffer.
    *
-   *    with ops.control_dependencies([ensure_lock_exists]):
-   *      return nest.map_structure(tf.identity, r)
-   *  }</pre>
-   *  While `fn` is running in the critical section, no other functions which wish to
-   *  use this critical section may run.
+   * @param scope is a scope used to add the underlying operation.
+   * @param type the tensor datatype.
+   * @param shape the tensor shape.
+   * @param data a buffer containing the tensor data.
+   * @return a constant of type `type`
+   * @throws IllegalArgumentException If the tensor datatype or shape is not compatible with the
+   *      buffer
+   */
+  public <T extends TType> Constant<T> constant(DataType<T> type, Shape shape,
+      ByteDataBuffer data) {
+    return Constant.tensorOf(scope, type, shape, data);
+  }
+
+  /**
+   * This op consumes a lock created by `MutexLock`.
    *  <p>
-   *  Often the use case is that two executions of the same graph, in parallel,
-   *  wish to run `fn`; and we wish to ensure that only one of them executes
-   *  at a time.  This is especially important if `fn` modifies one or more
-   *  variables at a time.
+   *  This op exists to consume a tensor created by `MutexLock` (other than
+   *  direct control dependencies).  It should be the only that consumes the tensor,
+   *  and will raise an error if it is not.  Its only purpose is to keep the
+   *  mutex lock tensor alive until it is consumed by this op.
    *  <p>
-   *  It is also useful if two separate functions must share a resource, but we
-   *  wish to ensure the usage is exclusive.
+   *  <b>NOTE</b>: This operation must run on the same device as its input.  This may
+   *  be enforced via the `colocate_with` mechanism.
    *
-   * @param mutex The mutex resource to lock.
-   * @return a new instance of MutexLock
+   * @param mutexLock A tensor returned by `MutexLock`.
+   * @return a new instance of ConsumeMutexLock
    */
-  public MutexLock mutexLock(Operand<?> mutex) {
-    return MutexLock.create(scope, mutex);
+  public ConsumeMutexLock consumeMutexLock(Operand<?> mutexLock) {
+    return ConsumeMutexLock.create(scope, mutexLock);
   }
 
   /**
-   * Makes its input available to the next iteration.
+   * Does nothing. Serves as a control trigger for scheduling.
+   *  <p>
+   *  Only useful as a placeholder for control edges.
+   *
+   * @return a new instance of ControlTrigger
+   */
+  public ControlTrigger controlTrigger() {
+    return ControlTrigger.create(scope);
+  }
+
+  /**
+   * Increments 'ref' until it reaches 'limit'.
    *
    * @param <T> data type for {@code output()} output
-   * @param data The tensor to be made available to the next iteration.
-   * @return a new instance of NextIteration
+   * @param ref Should be from a scalar `Variable` node.
+   * @param limit If incrementing ref would bring it above limit, instead generates an
+   *  'OutOfRange' error.
+   * @return a new instance of CountUpTo
    */
-  public <T extends TType> NextIteration<T> nextIteration(Operand<T> data) {
-    return NextIteration.create(scope, data);
+  public <T extends TNumber> CountUpTo<T> countUpTo(Operand<T> ref, Long limit) {
+    return CountUpTo.create(scope, ref, limit);
   }
 
   /**
-   * Does nothing. Only useful as a placeholder for control edges.
+   * Makes a copy of `x`.
    *
-   * @return a new instance of NoOp
+   * @param <T> data type for {@code y()} output
+   * @param x The source tensor of type `T`.
+   * @return a new instance of DeepCopy
    */
-  public NoOp noOp() {
-    return NoOp.create(scope);
+  public <T extends TType> DeepCopy<T> deepCopy(Operand<T> x) {
+    return DeepCopy.create(scope, x);
   }
 
   /**
-   * Returns a one-hot tensor.
-   *  <p>
-   *  The locations represented by indices in `indices` take value `on_value`,
-   *  while all other locations take value `off_value`.
-   *  <p>
-   *  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).
+   * Delete the tensor specified by its handle in the session.
+   *
+   * @param handle The handle for a tensor stored in the session state.
+   * @return a new instance of DeleteSessionTensor
+   */
+  public DeleteSessionTensor deleteSessionTensor(Operand<TString> handle) {
+    return DeleteSessionTensor.create(scope, handle);
+  }
+
+  /**
+   * Deletes the resource specified by the handle.
    *  <p>
-   *  If `indices` is a scalar the output shape will be a vector of length `depth`.
+   *  All subsequent operations using the resource will result in a NotFound
+   *  error status.
+   *
+   * @param resource handle to the resource to delete.
+   * @param options carries optional attributes values
+   * @return a new instance of DestroyResourceOp
+   */
+  public DestroyResourceOp destroyResourceOp(Operand<?> resource,
+      DestroyResourceOp.Options... options) {
+    return DestroyResourceOp.create(scope, resource, options);
+  }
+
+  /**
+   * Destroys the temporary variable and returns its final value.
    *  <p>
-   *  If `indices` is a vector of length `features`, the output shape will be:
-   *  <pre>{@code
-   *    features x depth if axis == -1
-   *    depth x features if axis == 0
-   *  }</pre>
-   *  If `indices` is a matrix (batch) with shape `[batch, features]`,
-   *  the output shape will be:
-   *  <pre>{@code
-   *    batch x features x depth if axis == -1
-   *    batch x depth x features if axis == 1
-   *    depth x batch x features if axis == 0
-   *  }</pre>
-   *  Examples
-   *  =========
+   *  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' <i>must</i> have executed before this op.
+   *  This is typically achieved by chaining the ref through each assign op, or by
+   *  using control dependencies.
    *  <p>
-   *  Suppose that
+   *  Outputs the final value of the tensor pointed to by 'ref'.
+   *
+   * @param <T> data type for {@code value()} output
+   * @param ref A reference to the temporary variable tensor.
+   * @param varName Name of the temporary variable, usually the name of the matching
+   *  'TemporaryVariable' op.
+   * @return a new instance of DestroyTemporaryVariable
+   */
+  public <T extends TType> DestroyTemporaryVariable<T> destroyTemporaryVariable(Operand<T> ref,
+      String varName) {
+    return DestroyTemporaryVariable.create(scope, ref, varName);
+  }
+
+  /**
+   * Partitions `data` into `num_partitions` tensors using indices from `partitions`.
+   *  <p>
+   *  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,
    *  <pre>{@code
-   *    indices = [0, 2, -1, 1]
-   *    depth = 3
-   *    on_value = 5.0
-   *    off_value = 0.0
-   *    axis = -1
+   *      outputs[i].shape = [sum(partitions == i)] + data.shape[partitions.ndim:]
+   *
+   *      outputs[i] = pack([data[js, ...] for js if partitions[js] == i])
    *  }</pre>
-   *  Then output is `[4 x 3]`:
+   *  `data.shape` must start with `partitions.shape`.
+   *  <p>
+   *  For example:
    *  <pre>{@code
-   *  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)
+   *      # 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]
    *  }</pre>
-   *  Suppose that
+   *  See `dynamic_stitch` for an example on how to merge partitions back.
+   *  <p>
+   *  <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>
+   *
+   * @param <T> data type for {@code outputs()} output
+   * @param data
+   * @param partitions Any shape.  Indices in the range `[0, num_partitions)`.
+   * @param numPartitions The number of partitions to output.
+   * @return a new instance of DynamicPartition
+   */
+  public <T extends TType> DynamicPartition<T> dynamicPartition(Operand<T> data,
+      Operand<TInt32> partitions, Long numPartitions) {
+    return DynamicPartition.create(scope, data, partitions, numPartitions);
+  }
+
+  /**
+   * Interleave the values from the `data` tensors into a single tensor.
+   *  <p>
+   *  Builds a merged tensor such that
    *  <pre>{@code
-   *    indices = [0, 2, -1, 1]
-   *    depth = 3
-   *    on_value = 0.0
-   *    off_value = 3.0
-   *    axis = 0
+   *      merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]
    *  }</pre>
-   *  Then output is `[3 x 4]`:
+   *  For example, if each `indices[m]` is scalar or vector, we have
    *  <pre>{@code
-   *  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)
+   *      # Scalar indices:
+   *      merged[indices[m], ...] = data[m][...]
+   *
+   *      # Vector indices:
+   *      merged[indices[m][i], ...] = data[m][i, ...]
    *  }</pre>
-   *  Suppose that
+   *  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
+   *  <p>
+   *      merged.shape = [max(indices)] + constant
+   *  <p>
+   *  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.
+   *  <p>
+   *  For example:
    *  <pre>{@code
-   *    indices = [[0, 2], [1, -1]]
-   *    depth = 3
-   *    on_value = 1.0
-   *    off_value = 0.0
-   *    axis = -1
+   *      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]]
    *  }</pre>
-   *  Then output is `[2 x 2 x 3]`:
+   *  This method can be used to merge partitions created by `dynamic_partition`
+   *  as illustrated on the following example:
    *  <pre>{@code
-   *  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)
-   *    ]
+   *      # 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.
    *  }</pre>
+   *  <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>
    *
-   * @param <U> data type for {@code output()} output
-   * @param indices A tensor of indices.
-   * @param depth A scalar defining the depth of the one hot dimension.
-   * @param onValue A scalar defining the value to fill in output when `indices[j] = i`.
-   * @param offValue A scalar defining the value to fill in output when `indices[j] != i`.
-   * @param options carries optional attributes values
-   * @return a new instance of OneHot
-   */
-  public <U extends TType, T extends TNumber> OneHot<U> oneHot(Operand<T> indices,
-      Operand<TInt32> depth, Operand<U> onValue, Operand<U> offValue, OneHot.Options... options) {
-    return OneHot.create(scope, indices, depth, onValue, offValue, options);
-  }
-
-  /**
-   * Returns a tensor of ones with the same shape and type as x.
-   *
-   * @param <T> data type for {@code y()} output
-   * @param x a tensor of type T.
-   * @return a new instance of OnesLike
+   * @param <T> data type for {@code merged()} output
+   * @param indices
+   * @param data
+   * @return a new instance of DynamicStitch
    */
-  public <T extends TType> OnesLike<T> onesLike(Operand<T> x) {
-    return OnesLike.create(scope, x);
+  public <T extends TType> DynamicStitch<T> dynamicStitch(Iterable<Operand<TInt32>> indices,
+      Iterable<Operand<T>> data) {
+    return DynamicStitch.create(scope, indices, data);
   }
 
   /**
-   * Op removes all elements in the underlying container.
+   * Computes the (possibly normalized) Levenshtein Edit Distance.
+   *  <p>
+   *  The inputs are variable-length sequences provided by SparseTensors
+   *    (hypothesis_indices, hypothesis_values, hypothesis_shape)
+   *  and
+   *    (truth_indices, truth_values, truth_shape).
+   *  <p>
+   *  The inputs are:
    *
-   * @param dtypes
+   * @param hypothesisIndices The indices of the hypothesis list SparseTensor.
+   *  This is an N x R int64 matrix.
+   * @param hypothesisValues The values of the hypothesis list SparseTensor.
+   *  This is an N-length vector.
+   * @param hypothesisShape The shape of the hypothesis list SparseTensor.
+   *  This is an R-length vector.
+   * @param truthIndices The indices of the truth list SparseTensor.
+   *  This is an M x R int64 matrix.
+   * @param truthValues The values of the truth list SparseTensor.
+   *  This is an M-length vector.
+   * @param truthShape truth indices, vector.
    * @param options carries optional attributes values
-   * @return a new instance of OrderedMapClear
+   * @return a new instance of EditDistance
    */
-  public OrderedMapClear orderedMapClear(List<DataType<?>> dtypes,
-      OrderedMapClear.Options... options) {
-    return OrderedMapClear.create(scope, dtypes, options);
+  public <T extends TType> EditDistance editDistance(Operand<TInt64> hypothesisIndices,
+      Operand<T> hypothesisValues, Operand<TInt64> hypothesisShape, Operand<TInt64> truthIndices,
+      Operand<T> truthValues, Operand<TInt64> truthShape, EditDistance.Options... options) {
+    return EditDistance.create(scope, hypothesisIndices, hypothesisValues, hypothesisShape, truthIndices, truthValues, truthShape, options);
   }
 
   /**
-   * Op returns the number of incomplete elements in the underlying container.
+   * Creates a tensor with the given shape.
+   *  <p>
+   *  This operation creates a tensor of `shape` and `dtype`.
    *
-   * @param dtypes
+   * @param <T> data type for {@code output()} output
+   * @param shape 1-D. Represents the shape of the output tensor.
+   * @param dtype
    * @param options carries optional attributes values
-   * @return a new instance of OrderedMapIncompleteSize
+   * @return a new instance of Empty
    */
-  public OrderedMapIncompleteSize orderedMapIncompleteSize(List<DataType<?>> dtypes,
-      OrderedMapIncompleteSize.Options... options) {
-    return OrderedMapIncompleteSize.create(scope, dtypes, options);
+  public <T extends TType> Empty<T> empty(Operand<TInt32> shape, DataType<T> dtype,
+      Empty.Options... options) {
+    return Empty.create(scope, shape, dtype, options);
   }
 
   /**
-   * Op peeks at the values at the specified key.  If the
+   * Creates and returns an empty tensor list.
    *  <p>
-   *  underlying container does not contain this key
-   *  this op will block until it does.   This Op is optimized for
-   *  performance.
+   *  All list elements must be tensors of dtype element_dtype and shape compatible
+   *  with element_shape.
+   *  <p>
+   *  handle: an empty tensor list.
+   *  element_dtype: the type of elements in the list.
+   *  element_shape: a shape compatible with that of elements in the list.
    *
-   * @param key
-   * @param indices
-   * @param dtypes
-   * @param options carries optional attributes values
-   * @return a new instance of OrderedMapPeek
+   * @param elementShape
+   * @param maxNumElements
+   * @param elementDtype
+   * @return a new instance of EmptyTensorList
    */
-  public OrderedMapPeek orderedMapPeek(Operand<TInt64> key, Operand<TInt32> indices,
-      List<DataType<?>> dtypes, OrderedMapPeek.Options... options) {
-    return OrderedMapPeek.create(scope, key, indices, dtypes, options);
+  public <T extends TNumber, U extends TType> EmptyTensorList emptyTensorList(
+      Operand<T> elementShape, Operand<TInt32> maxNumElements, DataType<U> elementDtype) {
+    return EmptyTensorList.create(scope, elementShape, maxNumElements, elementDtype);
   }
 
   /**
-   * Op returns the number of elements in the underlying container.
+   * Ensures that the tensor's shape matches the expected shape.
+   *  <p>
+   *  Raises an error if the input tensor's shape does not match the specified shape.
+   *  Returns the input tensor otherwise.
    *
-   * @param dtypes
-   * @param options carries optional attributes values
-   * @return a new instance of OrderedMapSize
+   * @param <T> data type for {@code output()} output
+   * @param input A tensor, whose shape is to be validated.
+   * @param shape The expected (possibly partially specified) shape of the input tensor.
+   * @return a new instance of EnsureShape
    */
-  public OrderedMapSize orderedMapSize(List<DataType<?>> dtypes,
-      OrderedMapSize.Options... options) {
-    return OrderedMapSize.create(scope, dtypes, options);
+  public <T extends TType> EnsureShape<T> ensureShape(Operand<T> input, Shape shape) {
+    return EnsureShape.create(scope, input, shape);
   }
 
   /**
-   * Stage (key, values) in the underlying container which behaves like a ordered
+   * Inserts a dimension of 1 into a tensor's shape.
    *  <p>
-   *  associative container.   Elements are ordered by key.
+   *  Given a tensor `input`, this operation inserts a dimension of 1 at the
+   *  dimension index `axis` of `input`'s shape. The dimension index `axis` starts at
+   *  zero; if you specify a negative number for `axis` it is counted backward from
+   *  the end.
+   *  <p>
+   *  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]`.
+   *  <p>
+   *  Other examples:
+   *  <pre>{@code
+   *  # '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]
    *
-   * @param key int64
-   * @param indices
-   * @param values a list of tensors
-   *  dtypes A list of data types that inserted values should adhere to.
-   * @param dtypes
-   * @param options carries optional attributes values
-   * @return a new instance of OrderedMapStage
-   */
-  public OrderedMapStage orderedMapStage(Operand<TInt64> key, Operand<TInt32> indices,
-      Iterable<Operand<?>> values, List<DataType<?>> dtypes, OrderedMapStage.Options... options) {
-    return OrderedMapStage.create(scope, key, indices, values, dtypes, options);
-  }
-
-  /**
-   * Op removes and returns the values associated with the key
+   *  # '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]
+   *  }</pre>
+   *  This operation requires that:
    *  <p>
-   *  from the underlying container.   If the underlying container
-   *  does not contain this key, the op will block until it does.
+   *  `-1-input.dims() <= dim <= input.dims()`
+   *  <p>
+   *  This operation is related to `squeeze()`, which removes dimensions of
+   *  size 1.
    *
-   * @param key
-   * @param indices
-   * @param dtypes
-   * @param options carries optional attributes values
-   * @return a new instance of OrderedMapUnstage
+   * @param <T> data type for {@code output()} output
+   * @param input
+   * @param axis 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)]`.
+   * @return a new instance of ExpandDims
    */
-  public OrderedMapUnstage orderedMapUnstage(Operand<TInt64> key, Operand<TInt32> indices,
-      List<DataType<?>> dtypes, OrderedMapUnstage.Options... options) {
-    return OrderedMapUnstage.create(scope, key, indices, dtypes, options);
+  public <T extends TType, U extends TNumber> ExpandDims<T> expandDims(Operand<T> input,
+      Operand<U> axis) {
+    return ExpandDims.create(scope, input, axis);
   }
 
   /**
-   * Op removes and returns the (key, value) element with the smallest
-   *  <p>
-   *  key from the underlying container.   If the underlying container
-   *  does not contain elements, the op will block until it does.
+   * Extract `patches` from `input` and put them in the "depth" output dimension. 3D extension of `extract_image_patches`.
    *
-   * @param indices
-   * @param dtypes
-   * @param options carries optional attributes values
-   * @return a new instance of OrderedMapUnstageNoKey
+   * @param <T> data type for {@code patches()} output
+   * @param input 5-D Tensor with shape `[batch, in_planes, in_rows, in_cols, depth]`.
+   * @param ksizes The size of the sliding window for each dimension of `input`.
+   * @param strides 1-D of length 5. How far the centers of two consecutive patches are in
+   *  `input`. Must be: `[1, stride_planes, stride_rows, stride_cols, 1]`.
+   * @param padding The type of padding algorithm to use.
+   *  <p>
+   *  We specify the size-related attributes as:
+   *  <pre>{@code
+   *        ksizes = [1, ksize_planes, ksize_rows, ksize_cols, 1]
+   *        strides = [1, stride_planes, strides_rows, strides_cols, 1]
+   *  }</pre>
+   * @return a new instance of ExtractVolumePatches
    */
-  public OrderedMapUnstageNoKey orderedMapUnstageNoKey(Operand<TInt32> indices,
-      List<DataType<?>> dtypes, OrderedMapUnstageNoKey.Options... options) {
-    return OrderedMapUnstageNoKey.create(scope, indices, dtypes, options);
+  public <T extends TNumber> ExtractVolumePatches<T> extractVolumePatches(Operand<T> input,
+      List<Long> ksizes, List<Long> strides, String padding) {
+    return ExtractVolumePatches.create(scope, input, ksizes, strides, padding);
   }
 
   /**
-   * Pads a tensor.
-   *  <p>
-   *  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`.
-   *  <p>
-   *  The padded size of each dimension D of the output is:
+   * Creates a tensor filled with a scalar value.
    *  <p>
-   *  `paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
+   *  This operation creates a tensor of shape `dims` and fills it with `value`.
    *  <p>
    *  For example:
    *  <pre>{@code
-   *  # '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]]
+   *  # Output tensor has shape [2, 3].
+   *  fill([2, 3], 9) ==> [[9, 9, 9]
+   *                       [9, 9, 9]]
    *  }</pre>
+   *  `tf.fill` differs from `tf.constant` in a few ways:
+   *  <ul>
+   *  <li>
+   *  `tf.fill` only supports scalar contents, whereas `tf.constant` supports
+   *      Tensor values.
+   *  </li>
+   *  <li>
+   *  `tf.fill` creates an Op in the computation graph that constructs the actual
+   *      Tensor value at runtime. This is in contrast to `tf.constant` which embeds
+   *      the entire Tensor into the graph with a `Const` node.
+   *  </li>
+   *  <li>
+   *  Because `tf.fill` evaluates at graph runtime, it supports dynamic shapes
+   *      based on other runtime Tensors, unlike `tf.constant`.
    *
-   * @param <T> data type for {@code output()} output
-   * @param input
-   * @param paddings
-   * @param constantValues
-   * @return a new instance of Pad
+   * @param <U> data type for {@code output()} output
+   * @param dims 1-D. Represents the shape of the output tensor.
+   * @param value 0-D (scalar). Value to fill the returned tensor.
+   *  <p>
+   * @compatibility(numpy) Equivalent to np.full
+   * @end_compatibility
+   * @return a new instance of Fill
    */
-  public <T extends TType, U extends TNumber> Pad<T> pad(Operand<T> input, Operand<U> paddings,
-      Operand<T> constantValues) {
-    return Pad.create(scope, input, paddings, constantValues);
+  public <U extends TType, T extends TNumber> Fill<U> fill(Operand<T> dims, Operand<U> value) {
+    return Fill.create(scope, dims, value);
   }
 
   /**
-   * Concatenates a list of `N` tensors along the first dimension.
+   * Generates fingerprint values.
    *  <p>
-   *  The input tensors are all required to have size 1 in the first dimension.
+   *  Generates fingerprint values of `data`.
    *  <p>
-   *  For example:
+   *  Fingerprint op considers the first dimension of `data` as the batch dimension,
+   *  and `output[i]` contains the fingerprint value generated from contents in
+   *  `data[i, ...]` for all `i`.
+   *  <p>
+   *  Fingerprint op writes fingerprint values as byte arrays. For example, the
+   *  default method `farmhash64` generates a 64-bit fingerprint value at a time.
+   *  This 8-byte value is written out as an `uint8` array of size 8, in little-endian
+   *  order.
+   *  <p>
+   *  For example, suppose that `data` has data type `DT_INT32` and shape (2, 3, 4),
+   *  and that the fingerprint method is `farmhash64`. In this case, the output shape
+   *  is (2, 8), where 2 is the batch dimension size of `data`, and 8 is the size of
+   *  each fingerprint value in bytes. `output[0, :]` is generated from 12 integers in
+   *  `data[0, :, :]` and similarly `output[1, :]` is generated from other 12 integers
+   *  in `data[1, :, :]`.
+   *  <p>
+   *  Note that this op fingerprints the raw underlying buffer, and it does not
+   *  fingerprint Tensor's metadata such as data type and/or shape. For example, the
+   *  fingerprint values are invariant under reshapes and bitcasts as long as the
+   *  batch dimension remain the same:
    *  <pre>{@code
-   *  # '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.
+   *  Fingerprint(data) == Fingerprint(Reshape(data, ...))
+   *  Fingerprint(data) == Fingerprint(Bitcast(data, ...))
    *  }</pre>
-   *  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.
+   *  For string data, one should expect `Fingerprint(data) !=
+   *  Fingerprint(ReduceJoin(data))` in general.
    *
-   * @param <T> data type for {@code output()} output
-   * @param values Tensors to be concatenated. All must have size 1 in the first dimension
-   *  and same shape.
-   * @param shape 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.
-   * @return a new instance of ParallelConcat
+   * @param data Must have rank 1 or higher.
+   * @param method Fingerprint method used by this op. Currently available method is
+   *  `farmhash::fingerprint64`.
+   * @return a new instance of Fingerprint
    */
-  public <T extends TType> ParallelConcat<T> parallelConcat(Iterable<Operand<T>> values,
-      Shape shape) {
-    return ParallelConcat.create(scope, values, shape);
+  public <T extends TType> Fingerprint fingerprint(Operand<T> data, Operand<TString> method) {
+    return Fingerprint.create(scope, data, method);
   }
 
   /**
-   * Interleave the values from the `data` tensors into a single tensor.
+   * Gather slices from `params` axis `axis` according to `indices`.
    *  <p>
-   *  Builds a merged tensor such that
-   *  <pre>{@code
-   *      merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]
-   *  }</pre>
-   *  For example, if each `indices[m]` is scalar or vector, we have
+   *  `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:
    *  <pre>{@code
-   *      # Scalar indices:
-   *      merged[indices[m], ...] = data[m][...]
-   *
-   *      # Vector indices:
-   *      merged[indices[m][i], ...] = data[m][i, ...]
-   *  }</pre>
-   *  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
-   *  <p>
-   *      merged.shape = [max(indices)] + constant
-   *  <p>
-   *  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.
-   *  <p>
-   *  For example:
-   *  <pre>{@code
-   *      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]]
-   *  }</pre>
-   *  This method can be used to merge partitions created by `dynamic_partition`
-   *  as illustrated on the following example:
-   *  <pre>{@code
-   *      # 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.
+   *      # 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]
    *  }</pre>
    *  <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>
+   *  <img style="width:100%" src="https://www.tensorflow.org/images/Gather.png" alt>
    *  </div>
+   *  <p>
+   *  Note that on CPU, if an out of bound index is found, an error is returned.
+   *  On GPU, if an out of bound index is found, a 0 is stored in the
+   *  corresponding output value.
+   *  <p>
+   *  See also `tf.batch_gather` and `tf.gather_nd`.
    *
-   * @param <T> data type for {@code merged()} output
-   * @param indices
-   * @param data
-   * @return a new instance of ParallelDynamicStitch
+   * @param <T> data type for {@code output()} output
+   * @param params The tensor from which to gather values. Must be at least rank
+   *  `axis + 1`.
+   * @param indices Index tensor. Must be in range `[0, params.shape[axis])`.
+   * @param axis The axis in `params` to gather `indices` from. Defaults to the first
+   *  dimension. Supports negative indexes.
+   * @param options carries optional attributes values
+   * @return a new instance of Gather
    */
-  public <T extends TType> ParallelDynamicStitch<T> parallelDynamicStitch(
-      Iterable<Operand<TInt32>> indices, Iterable<Operand<T>> data) {
-    return ParallelDynamicStitch.create(scope, indices, data);
+  public <T extends TType, U extends TNumber, V extends TNumber> Gather<T> gather(Operand<T> params,
+      Operand<U> indices, Operand<V> axis, Gather.Options... options) {
+    return Gather.create(scope, params, indices, axis, options);
   }
 
   /**
-   * A placeholder op for a value that will be fed into the computation.
+   * Gather slices from `params` into a Tensor with shape specified by `indices`.
    *  <p>
-   *  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.
+   *  `indices` is a 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`:
+   *  <p>
+   *      output[\\(i_0, ..., i_{K-2}\\)] = params[indices[\\(i_0, ..., i_{K-2}\\)]]
+   *  <p>
+   *  Whereas in `tf.gather` `indices` defines slices into the `axis`
+   *  dimension of `params`, in `tf.gather_nd`, `indices` defines slices into the
+   *  first `N` dimensions of `params`, where `N = indices.shape[-1]`.
+   *  <p>
+   *  The last dimension of `indices` can be at most the rank of
+   *  `params`:
+   *  <p>
+   *      indices.shape[-1] <= params.rank
+   *  <p>
+   *  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
+   *  <p>
+   *      indices.shape[:-1] + params.shape[indices.shape[-1]:]
+   *  <p>
+   *  Note that on CPU, if an out of bound index is found, an error is returned.
+   *  On GPU, if an out of bound index is found, a 0 is stored in the
+   *  corresponding output value.
+   *  <p>
+   *  Some examples below.
+   *  <p>
+   *  Simple indexing into a matrix:
+   *  <pre>{@code
+   *      indices = [[0, 0], [1, 1]]
+   *      params = [['a', 'b'], ['c', 'd']]
+   *      output = ['a', 'd']
+   *  }</pre>
+   *  Slice indexing into a matrix:
+   *  <pre>{@code
+   *      indices = [[1], [0]]
+   *      params = [['a', 'b'], ['c', 'd']]
+   *      output = [['c', 'd'], ['a', 'b']]
+   *  }</pre>
+   *  Indexing into a 3-tensor:
+   *  <pre>{@code
+   *      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']
+   *  }</pre>
+   *  Batched indexing into a matrix:
+   *  <pre>{@code
+   *      indices = [[[0, 0]], [[0, 1]]]
+   *      params = [['a', 'b'], ['c', 'd']]
+   *      output = [['a'], ['b']]
+   *  }</pre>
+   *  Batched slice indexing into a matrix:
+   *  <pre>{@code
+   *      indices = [[[1]], [[0]]]
+   *      params = [['a', 'b'], ['c', 'd']]
+   *      output = [[['c', 'd']], [['a', 'b']]]
+   *  }</pre>
+   *  Batched indexing into a 3-tensor:
+   *  <pre>{@code
+   *      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']]
+   *  }</pre>
+   *  See also `tf.gather` and `tf.batch_gather`.
    *
    * @param <T> data type for {@code output()} output
-   * @param dtype The type of elements in the tensor.
-   * @param options carries optional attributes values
-   * @return a new instance of Placeholder
+   * @param params The tensor from which to gather values.
+   * @param indices Index tensor.
+   * @return a new instance of GatherNd
    */
-  public <T extends TType> Placeholder<T> placeholder(DataType<T> dtype,
-      Placeholder.Options... options) {
-    return Placeholder.create(scope, dtype, options);
+  public <T extends TType, U extends TNumber> GatherNd<T> gatherNd(Operand<T> params,
+      Operand<U> indices) {
+    return GatherNd.create(scope, params, indices);
   }
 
   /**
-   * A placeholder op that passes through `input` when its output is not fed.
+   * Store the input tensor in the state of the current session.
    *
-   * @param <T> data type for {@code output()} output
-   * @param input The default value to produce when `output` is not fed.
-   * @param shape The (possibly partial) shape of the tensor.
-   * @return a new instance of PlaceholderWithDefault
+   * @param value The tensor to be stored.
+   * @return a new instance of GetSessionHandle
    */
-  public <T extends TType> PlaceholderWithDefault<T> placeholderWithDefault(Operand<T> input,
-      Shape shape) {
-    return PlaceholderWithDefault.create(scope, input, shape);
+  public <T extends TType> GetSessionHandle getSessionHandle(Operand<T> value) {
+    return GetSessionHandle.create(scope, value);
   }
 
   /**
-   * Prints a string scalar.
-   *  <p>
-   *  Prints a string scalar to the desired output_stream.
+   * Get the value of the tensor specified by its handle.
    *
-   * @param input The string scalar to print.
-   * @param options carries optional attributes values
-   * @return a new instance of Print
+   * @param <T> data type for {@code value()} output
+   * @param handle The handle for a tensor stored in the session state.
+   * @param dtype The type of the output value.
+   * @return a new instance of GetSessionTensor
    */
-  public Print print(Operand<TString> input, Print.Options... options) {
-    return Print.create(scope, input, options);
+  public <T extends TType> GetSessionTensor<T> getSessionTensor(Operand<TString> handle,
+      DataType<T> dtype) {
+    return GetSessionTensor.create(scope, handle, dtype);
   }
 
   /**
-   * Computes the product of elements across dimensions of a tensor.
-   *  <p>
-   *  Reduces `input` 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 are
-   *  retained with length 1.
+   * Adds gradients computation ops to the graph according to scope.
    *
-   * @param <T> data type for {@code output()} output
-   * @param input The tensor to reduce.
-   * @param axis The dimensions to reduce. Must be in the range
-   *  `[-rank(input), rank(input))`.
+   * @param scope current graph scope
+   * @param y outputs of the function to derive
+   * @param x inputs of the function for which partial derivatives are computed
    * @param options carries optional attributes values
-   * @return a new instance of Prod
+   * @return a new instance of {@code Gradients}
+   * @throws IllegalArgumentException if execution environment is not a graph
    */
-  public <T extends TType, U extends TNumber> Prod<T> prod(Operand<T> input, Operand<U> axis,
-      Prod.Options... options) {
-    return Prod.create(scope, input, axis, options);
+  public Gradients gradients(Iterable<? extends Operand<?>> y, Iterable<? extends Operand<?>> x,
+      Gradients.Options... options) {
+    return Gradients.create(scope, y, x, options);
   }
 
   /**
-   * Reshapes a quantized tensor as per the Reshape op.
+   * Adds operations to compute the partial derivatives of sum of {@code y}s w.r.t {@code x}s,
+   *  i.e., {@code d(y_1 + y_2 + ...)/dx_1, d(y_1 + y_2 + ...)/dx_2...}
+   *  <p> 
+   *  If {@code Options.dx()} values are set, they are as the initial symbolic partial derivatives of some loss 
+   *  function {@code L} w.r.t. {@code y}. {@code Options.dx()} must have the size of {@code y}.
    *  <p>
-   *  ```
+   *  If {@code Options.dx()} is not set, the implementation will use dx of {@code OnesLike} for all
+   *  shapes in {@code y}.
+   *  <p>
+   *  The partial derivatives are returned in output {@code dy}, with the size of {@code x}.
+   *  <p>
+   *  Example of usage:
+   *  <pre>{@code
+   *  Gradients gradients = tf.gradients(loss, Arrays.asList(w, b));
+   *  Constant<TFloat32> alpha = tf.constant(1.0f);
+   *  tf.train.applyGradientDescent(w, alpha, gradients.<Float>dy(0));
+   *  tf.train.applyGradientDescent(b, alpha, gradients.<Float>dy(1));
+   *  }</pre>
    *
-   * @param <T> data type for {@code output()} output
-   * @param tensor
-   * @param shape Defines the shape of the output tensor.
-   * @param inputMin The minimum value of the input.
-   * @param inputMax The maximum value of the input.
-   * @return a new instance of QuantizedReshape
+   * @param y output of the function to derive
+   * @param x inputs of the function for which partial derivatives are computed
+   * @param options carries optional attributes values
+   * @return a new instance of {@code Gradients}
+   * @throws IllegalArgumentException if execution environment is not a graph
    */
-  public <T extends TType, U extends TNumber> QuantizedReshape<T> quantizedReshape(
-      Operand<T> tensor, Operand<U> shape, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax) {
-    return QuantizedReshape.create(scope, tensor, shape, inputMin, inputMax);
+  public Gradients gradients(Operand<?> y, Iterable<? extends Operand<?>> x,
+      Gradients.Options... options) {
+    return Gradients.create(scope, y, x, options);
   }
 
   /**
-   * Creates a sequence of numbers.
+   * Gives a guarantee to the TF runtime that the input tensor is a constant.
    *  <p>
-   *  This operation creates a sequence of numbers that begins at `start` and
-   *  extends by increments of `delta` up to but not including `limit`.
+   *  The runtime is then free to make optimizations based on this.
    *  <p>
-   *  For example:
-   *  <pre>{@code
-   *  # 'start' is 3
-   *  # 'limit' is 18
-   *  # 'delta' is 3
-   *  tf.range(start, limit, delta) ==> [3, 6, 9, 12, 15]
-   *  }</pre>
+   *  Only accepts value typed tensors as inputs and rejects resource variable handles
+   *  as input.
+   *  <p>
+   *  Returns the input tensor without modification.
    *
    * @param <T> data type for {@code output()} output
-   * @param start 0-D (scalar). First entry in the sequence.
-   * @param limit 0-D (scalar). Upper limit of sequence, exclusive.
-   * @param delta 0-D (scalar). Optional. Default is 1. Number that increments `start`.
-   * @return a new instance of Range
+   * @param input
+   * @return a new instance of GuaranteeConst
    */
-  public <T extends TNumber> Range<T> range(Operand<T> start, Operand<T> limit, Operand<T> delta) {
-    return Range.create(scope, start, limit, delta);
+  public <T extends TType> GuaranteeConst<T> guaranteeConst(Operand<T> input) {
+    return GuaranteeConst.create(scope, input);
   }
 
   /**
-   * Returns the rank of a tensor.
-   *  <p>
-   *  This operation returns an integer representing the rank of `input`.
+   * Creates a non-initialized hash table.
    *  <p>
-   *  For example:
-   *  <pre>{@code
-   *  # '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
-   *  }</pre>
-   *  <b>Note</b>: 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."
+   *  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.
    *
-   * @param input
-   * @return a new instance of Rank
+   * @param keyDtype Type of the table keys.
+   * @param valueDtype Type of the table values.
+   * @param options carries optional attributes values
+   * @return a new instance of HashTable
    */
-  public <T extends TType> Rank rank(Operand<T> input) {
-    return Rank.create(scope, input);
+  public <T extends TType, U extends TType> HashTable hashTable(DataType<T> keyDtype,
+      DataType<U> valueDtype, HashTable.Options... options) {
+    return HashTable.create(scope, keyDtype, valueDtype, options);
   }
 
   /**
-   * Reads the value of a variable.
-   *  <p>
-   *  The tensor returned by this operation is immutable.
+   * Return histogram of values.
    *  <p>
-   *  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.
+   *  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`.
+   *  <pre>{@code
+   *  # 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]
    *
-   * @param <T> data type for {@code value()} output
-   * @param resource handle to the resource in which to store the variable.
-   * @param dtype the dtype of the value.
-   * @return a new instance of ReadVariableOp
+   *  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]
+   *  }</pre>
+   *
+   * @param <U> data type for {@code out()} output
+   * @param values Numeric `Tensor`.
+   * @param valueRange 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].
+   * @param nbins Scalar `int32 Tensor`.  Number of histogram bins.
+   * @return a new instance of HistogramFixedWidth
    */
-  public <T extends TType> ReadVariableOp<T> readVariableOp(Operand<?> resource,
-      DataType<T> dtype) {
-    return ReadVariableOp.create(scope, resource, dtype);
+  public <T extends TNumber> HistogramFixedWidth<TInt32> histogramFixedWidth(Operand<T> values,
+      Operand<T> valueRange, Operand<TInt32> nbins) {
+    return HistogramFixedWidth.create(scope, values, valueRange, nbins);
   }
 
   /**
-   * Computes the "logical and" of elements across dimensions of a tensor.
+   * Return histogram of values.
    *  <p>
-   *  Reduces `input` 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 are
-   *  retained with length 1.
+   *  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`.
+   *  <pre>{@code
+   *  # 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]
    *
-   * @param input The tensor to reduce.
-   * @param axis The dimensions to reduce. Must be in the range
-   *  `[-rank(input), rank(input))`.
-   * @param options carries optional attributes values
-   * @return a new instance of ReduceAll
+   *  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]
+   *  }</pre>
+   *
+   * @param <U> data type for {@code out()} output
+   * @param values Numeric `Tensor`.
+   * @param valueRange 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].
+   * @param nbins Scalar `int32 Tensor`.  Number of histogram bins.
+   * @param dtype
+   * @return a new instance of HistogramFixedWidth
    */
-  public <T extends TNumber> ReduceAll reduceAll(Operand<TBool> input, Operand<T> axis,
-      ReduceAll.Options... options) {
-    return ReduceAll.create(scope, input, axis, options);
+  public <U extends TNumber, T extends TNumber> HistogramFixedWidth<U> histogramFixedWidth(
+      Operand<T> values, Operand<T> valueRange, Operand<TInt32> nbins, DataType<U> dtype) {
+    return HistogramFixedWidth.create(scope, values, valueRange, nbins, dtype);
   }
 
   /**
-   * Computes the "logical or" of elements across dimensions of a tensor.
-   *  <p>
-   *  Reduces `input` 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 are
-   *  retained with length 1.
+   * Return a tensor with the same shape and contents as the input tensor or value.
    *
-   * @param input The tensor to reduce.
-   * @param axis The dimensions to reduce. Must be in the range
-   *  `[-rank(input), rank(input))`.
-   * @param options carries optional attributes values
-   * @return a new instance of ReduceAny
+   * @param <T> data type for {@code output()} output
+   * @param input
+   * @return a new instance of Identity
    */
-  public <T extends TNumber> ReduceAny reduceAny(Operand<TBool> input, Operand<T> axis,
-      ReduceAny.Options... options) {
-    return ReduceAny.create(scope, input, axis, options);
+  public <T extends TType> Identity<T> identity(Operand<T> input) {
+    return Identity.create(scope, input);
   }
 
   /**
-   * Computes the maximum of elements across dimensions of a tensor.
+   * Returns a list of tensors with the same shapes and contents as the input
    *  <p>
-   *  Reduces `input` 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 are
-   *  retained with length 1.
+   *  tensors.
+   *  <p>
+   *  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,
+   *  <pre>{@code
+   *  with tf.get_default_graph().gradient_override_map(
+   *      {'IdentityN': 'OverrideGradientWithG'}):
+   *    y, _ = identity_n([f(x), x])
    *
-   * @param <T> data type for {@code output()} output
-   * @param input The tensor to reduce.
-   * @param axis The dimensions to reduce. Must be in the range
-   *  `[-rank(input), rank(input))`.
-   * @param options carries optional attributes values
-   * @return a new instance of ReduceMax
+   * @tf.RegisterGradient('OverrideGradientWithG') def ApplyG(op, dy, _):
+   *    return [None, g(dy)]  # Do not backprop to f(x).
+   *  }</pre>
+   * @param input
+   * @return a new instance of IdentityN
    */
-  public <T extends TType, U extends TNumber> ReduceMax<T> reduceMax(Operand<T> input,
-      Operand<U> axis, ReduceMax.Options... options) {
-    return ReduceMax.create(scope, input, axis, options);
+  public IdentityN identityN(Iterable<Operand<?>> input) {
+    return IdentityN.create(scope, input);
   }
 
   /**
-   * Computes the minimum of elements across dimensions of a tensor.
+   * Returns immutable tensor from memory region.
    *  <p>
-   *  Reduces `input` 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 are
-   *  retained with length 1.
+   *  The current implementation memmaps the tensor from a file.
    *
-   * @param <T> data type for {@code output()} output
-   * @param input The tensor to reduce.
-   * @param axis The dimensions to reduce. Must be in the range
-   *  `[-rank(input), rank(input))`.
-   * @param options carries optional attributes values
-   * @return a new instance of ReduceMin
+   * @param <T> data type for {@code tensor()} output
+   * @param dtype Type of the returned tensor.
+   * @param shape Shape of the returned tensor.
+   * @param memoryRegionName Name of readonly memory region used by the tensor, see
+   *  NewReadOnlyMemoryRegionFromFile in tensorflow::Env.
+   * @return a new instance of ImmutableConst
    */
-  public <T extends TType, U extends TNumber> ReduceMin<T> reduceMin(Operand<T> input,
-      Operand<U> axis, ReduceMin.Options... options) {
-    return ReduceMin.create(scope, input, axis, options);
+  public <T extends TType> ImmutableConst<T> immutableConst(DataType<T> dtype, Shape shape,
+      String memoryRegionName) {
+    return ImmutableConst.create(scope, dtype, shape, memoryRegionName);
   }
 
   /**
-   * Computes the product of elements across dimensions of a tensor.
-   *  <p>
-   *  Reduces `input` 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 are
-   *  retained with length 1.
+   * Table initializer that takes two tensors for keys and values respectively.
    *
-   * @param <T> data type for {@code output()} output
-   * @param input The tensor to reduce.
-   * @param axis The dimensions to reduce. Must be in the range
-   *  `[-rank(input), rank(input))`.
-   * @param options carries optional attributes values
-   * @return a new instance of ReduceProd
+   * @param tableHandle Handle to a table which will be initialized.
+   * @param keys Keys of type Tkey.
+   * @param values Values of type Tval.
+   * @return a new instance of InitializeTable
    */
-  public <T extends TType, U extends TNumber> ReduceProd<T> reduceProd(Operand<T> input,
-      Operand<U> axis, ReduceProd.Options... options) {
-    return ReduceProd.create(scope, input, axis, options);
+  public <T extends TType, U extends TType> InitializeTable initializeTable(Operand<?> tableHandle,
+      Operand<T> keys, Operand<U> values) {
+    return InitializeTable.create(scope, tableHandle, keys, values);
   }
 
   /**
-   * Computes the sum of elements across dimensions of a tensor.
+   * Initializes a table from a text file.
    *  <p>
-   *  Reduces `input` 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 are
-   *  retained with length 1.
-   *
-   * @param <T> data type for {@code output()} output
-   * @param input The tensor to reduce.
-   * @param axis The dimensions to reduce. Must be in the range
-   *  `[-rank(input), rank(input))`.
+   *  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`.
+   *  <p>
+   *  - 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`.
+   *
+   * @param tableHandle Handle to a table which will be initialized.
+   * @param filename Filename of a vocabulary text file.
+   * @param keyIndex Column index in a line to get the table `key` values from.
+   * @param valueIndex Column index that represents information of a line to get the table
+   *  `value` values from.
    * @param options carries optional attributes values
-   * @return a new instance of ReduceSum
+   * @return a new instance of InitializeTableFromTextFile
    */
-  public <T extends TType, U extends TNumber> ReduceSum<T> reduceSum(Operand<T> input,
-      Operand<U> axis, ReduceSum.Options... options) {
-    return ReduceSum.create(scope, input, axis, options);
+  public InitializeTableFromTextFile initializeTableFromTextFile(Operand<?> tableHandle,
+      Operand<TString> filename, Long keyIndex, Long valueIndex,
+      InitializeTableFromTextFile.Options... options) {
+    return InitializeTableFromTextFile.create(scope, tableHandle, filename, keyIndex, valueIndex, options);
   }
 
   /**
-   * Makes its input available to the next iteration.
+   *     Adds v into specified rows of x.
+   *  <p>
+   *      Computes y = x; y[i, :] += v; return y.
    *
-   * @param <T> data type for {@code output()} output
-   * @param data The tensor to be made available to the next iteration.
-   * @return a new instance of RefNextIteration
+   * @param <T> data type for {@code y()} output
+   * @param x A `Tensor` of type T.
+   * @param i A vector. Indices into the left-most dimension of `x`.
+   * @param v A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
+   * @return a new instance of InplaceAdd
    */
-  public <T extends TType> RefNextIteration<T> refNextIteration(Operand<T> data) {
-    return RefNextIteration.create(scope, data);
+  public <T extends TType> InplaceAdd<T> inplaceAdd(Operand<T> x, Operand<TInt32> i, Operand<T> v) {
+    return InplaceAdd.create(scope, x, i, v);
   }
 
   /**
-   * Forwards the `index`th element of `inputs` to `output`.
+   *     Subtracts `v` into specified rows of `x`.
+   *  <p>
+   *      Computes y = x; y[i, :] -= v; return y.
    *
-   * @param <T> data type for {@code output()} output
-   * @param index A scalar that determines the input that gets selected.
-   * @param inputs A list of ref tensors, one of which will be forwarded to `output`.
-   * @return a new instance of RefSelect
+   * @param <T> data type for {@code y()} output
+   * @param x A `Tensor` of type T.
+   * @param i A vector. Indices into the left-most dimension of `x`.
+   * @param v A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
+   * @return a new instance of InplaceSub
    */
-  public <T extends TType> RefSelect<T> refSelect(Operand<TInt32> index,
-      Iterable<Operand<T>> inputs) {
-    return RefSelect.create(scope, index, inputs);
+  public <T extends TType> InplaceSub<T> inplaceSub(Operand<T> x, Operand<TInt32> i, Operand<T> v) {
+    return InplaceSub.create(scope, x, i, v);
   }
 
   /**
-   * Forwards the ref tensor `data` to the output port determined by `pred`.
-   *  <p>
-   *  If `pred` is true, the `data` input is forwarded to `output_true`. Otherwise,
-   *  the data goes to `output_false`.
+   *     Updates specified rows with values in `v`.
    *  <p>
-   *  See also `Switch` and `Merge`.
+   *      Computes `x[i, :] = v; return x`.
    *
-   * @param <T> data type for {@code outputFalse()} output
-   * @param data The ref tensor to be forwarded to the appropriate output.
-   * @param pred A scalar that specifies which output port will receive data.
-   * @return a new instance of RefSwitch
+   * @param <T> data type for {@code y()} output
+   * @param x A tensor of type `T`.
+   * @param i A vector. Indices into the left-most dimension of `x`.
+   * @param v A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
+   * @return a new instance of InplaceUpdate
    */
-  public <T extends TType> RefSwitch<T> refSwitch(Operand<T> data, Operand<TBool> pred) {
-    return RefSwitch.create(scope, data, pred);
+  public <T extends TType> InplaceUpdate<T> inplaceUpdate(Operand<T> x, Operand<TInt32> i,
+      Operand<T> v) {
+    return InplaceUpdate.create(scope, x, i, v);
   }
 
   /**
-   * Execute a sub graph on a remote processor.
+   * Checks whether a tensor has been initialized.
    *  <p>
-   *  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.
+   *  Outputs boolean scalar indicating whether the tensor has been initialized.
    *
-   * @param inputs Arbitrary number of tensors with arbitrary data types
-   * @param Toutputs
-   * @param serializedRemoteFusedGraphExecuteInfo Serialized protocol buffer
-   *  of RemoteFusedGraphExecuteInfo which contains graph specifications.
-   * @return a new instance of RemoteFusedGraphExecute
+   * @param ref Should be from a `Variable` node. May be uninitialized.
+   * @return a new instance of IsVariableInitialized
    */
-  public RemoteFusedGraphExecute remoteFusedGraphExecute(Iterable<Operand<?>> inputs,
-      List<DataType<?>> Toutputs, String serializedRemoteFusedGraphExecuteInfo) {
-    return RemoteFusedGraphExecute.create(scope, inputs, Toutputs, serializedRemoteFusedGraphExecuteInfo);
+  public <T extends TType> IsVariableInitialized isVariableInitialized(Operand<T> ref) {
+    return IsVariableInitialized.create(scope, ref);
   }
 
   /**
-   * Reshapes a tensor.
-   *  <p>
-   *  Given `tensor`, this operation returns a tensor that has the same values
-   *  as `tensor` with shape `shape`.
-   *  <p>
-   *  If one component of 1-D tensor `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` may be
-   *  unknown.
-   *  <p>
-   *  The `shape` must be 1-D and 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`.
+   * Generates values in an interval.
    *  <p>
-   *  It is an error if `shape` is not 1-D.
+   *  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`.
    *  <p>
    *  For example:
    *  <pre>{@code
-   *  # 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
+   *  tf.linspace(10.0, 12.0, 3, name="linspace") => [ 10.0  11.0  12.0]
    *  }</pre>
    *
    * @param <T> data type for {@code output()} output
-   * @param tensor
-   * @param shape Defines the shape of the output tensor.
-   * @return a new instance of Reshape
+   * @param start 0-D tensor. First entry in the range.
+   * @param stop 0-D tensor. Last entry in the range.
+   * @param num 0-D tensor. Number of values to generate.
+   * @return a new instance of LinSpace
    */
-  public <T extends TType, U extends TNumber> Reshape<T> reshape(Operand<T> tensor,
-      Operand<U> shape) {
-    return Reshape.create(scope, tensor, shape);
+  public <T extends TNumber, U extends TNumber> LinSpace<T> linSpace(Operand<T> start,
+      Operand<T> stop, Operand<U> num) {
+    return LinSpace.create(scope, start, stop, num);
   }
 
   /**
-   * Increments variable pointed to by 'resource' until it reaches 'limit'.
+   * Outputs all keys and values in the table.
    *
-   * @param <T> data type for {@code output()} output
-   * @param resource Should be from a scalar `Variable` node.
-   * @param limit If incrementing ref would bring it above limit, instead generates an
-   *  'OutOfRange' error.
-   * @param T
-   * @return a new instance of ResourceCountUpTo
+   * @param <T> data type for {@code keys()} output
+   * @param <U> data type for {@code values()} output
+   * @param tableHandle Handle to the table.
+   * @param Tkeys
+   * @param Tvalues
+   * @return a new instance of LookupTableExport
    */
-  public <T extends TNumber> ResourceCountUpTo<T> resourceCountUpTo(Operand<?> resource, Long limit,
-      DataType<T> T) {
-    return ResourceCountUpTo.create(scope, resource, limit, T);
+  public <T extends TType, U extends TType> LookupTableExport<T, U> lookupTableExport(
+      Operand<?> tableHandle, DataType<T> Tkeys, DataType<U> Tvalues) {
+    return LookupTableExport.create(scope, tableHandle, Tkeys, Tvalues);
   }
 
   /**
-   * Gather slices from the variable pointed to by `resource` according to `indices`.
+   * Looks up keys in a table, outputs the corresponding values.
    *  <p>
-   *  `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:
-   *  <pre>{@code
-   *      # Scalar indices
-   *      output[:, ..., :] = params[indices, :, ... :]
-   *
-   *      # Vector indices
-   *      output[i, :, ..., :] = params[indices[i], :, ... :]
-   *
-   *      # Higher rank indices
-   *      output[i, ..., j, :, ... :] = params[indices[i, ..., j], :, ..., :]
-   *  }</pre>
+   *  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.
+   *  <p>
+   *  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.
    *
-   * @param <U> data type for {@code output()} output
-   * @param resource
-   * @param indices
-   * @param dtype
-   * @param options carries optional attributes values
-   * @return a new instance of ResourceGather
+   * @param <U> data type for {@code values()} output
+   * @param tableHandle Handle to the table.
+   * @param keys Any shape.  Keys to look up.
+   * @param defaultValue
+   * @return a new instance of LookupTableFind
    */
-  public <U extends TType, T extends TNumber> ResourceGather<U> resourceGather(Operand<?> resource,
-      Operand<T> indices, DataType<U> dtype, ResourceGather.Options... options) {
-    return ResourceGather.create(scope, resource, indices, dtype, options);
+  public <U extends TType, T extends TType> LookupTableFind<U> lookupTableFind(
+      Operand<?> tableHandle, Operand<T> keys, Operand<U> defaultValue) {
+    return LookupTableFind.create(scope, tableHandle, keys, defaultValue);
   }
 
   /**
+   * Replaces the contents of the table with the specified keys and values.
+   *  <p>
+   *  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.
    *
-   * @param <U> data type for {@code output()} output
-   * @param resource
-   * @param indices
-   * @param dtype
-   * @return a new instance of ResourceGatherNd
+   * @param tableHandle Handle to the table.
+   * @param keys Any shape.  Keys to look up.
+   * @param values Values to associate with keys.
+   * @return a new instance of LookupTableImport
    */
-  public <U extends TType, T extends TNumber> ResourceGatherNd<U> resourceGatherNd(
-      Operand<?> resource, Operand<T> indices, DataType<U> dtype) {
-    return ResourceGatherNd.create(scope, resource, indices, dtype);
+  public <T extends TType, U extends TType> LookupTableImport lookupTableImport(
+      Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
+    return LookupTableImport.create(scope, tableHandle, keys, values);
   }
 
   /**
-   * Adds sparse updates to the variable referenced by `resource`.
-   *  <p>
-   *  This operation computes
+   * Updates the table to associates keys with values.
    *  <p>
-   *      # Scalar indices
-   *      ref[indices, ...] += updates[...]
-   *  <p>
-   *      # Vector indices (for each i)
-   *      ref[indices[i], ...] += updates[i, ...]
-   *  <p>
-   *      # High rank indices (for each i, ..., j)
-   *      ref[indices[i, ..., j], ...] += updates[i, ..., j, ...]
-   *  <p>
-   *  Duplicate entries are handled correctly: if multiple `indices` reference
-   *  the same location, their contributions add.
-   *  <p>
-   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
-   *  <p>
-   *  <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>
+   *  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.
    *
-   * @param resource Should be from a `Variable` node.
-   * @param indices A tensor of indices into the first dimension of `ref`.
-   * @param updates A tensor of updated values to add to `ref`.
-   * @return a new instance of ResourceScatterAdd
+   * @param tableHandle Handle to the table.
+   * @param keys Any shape.  Keys to look up.
+   * @param values Values to associate with keys.
+   * @return a new instance of LookupTableInsert
    */
-  public <T extends TNumber, U extends TType> ResourceScatterAdd resourceScatterAdd(
-      Operand<?> resource, Operand<T> indices, Operand<U> updates) {
-    return ResourceScatterAdd.create(scope, resource, indices, updates);
+  public <T extends TType, U extends TType> LookupTableInsert lookupTableInsert(
+      Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
+    return LookupTableInsert.create(scope, tableHandle, keys, values);
   }
 
   /**
-   * Divides sparse updates into the variable referenced by `resource`.
-   *  <p>
-   *  This operation computes
-   *  <p>
-   *      # Scalar indices
-   *      ref[indices, ...] /= updates[...]
-   *  <p>
-   *      # Vector indices (for each i)
-   *      ref[indices[i], ...] /= updates[i, ...]
-   *  <p>
-   *      # High rank indices (for each i, ..., j)
-   *      ref[indices[i, ..., j], ...] /= updates[i, ..., j, ...]
-   *  <p>
-   *  Duplicate entries are handled correctly: if multiple `indices` reference
-   *  the same location, their contributions multiply.
-   *  <p>
-   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
-   *  <p>
-   *  <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>
+   * Computes the number of elements in the given table.
    *
-   * @param resource Should be from a `Variable` node.
-   * @param indices A tensor of indices into the first dimension of `ref`.
-   * @param updates A tensor of updated values to add to `ref`.
-   * @return a new instance of ResourceScatterDiv
+   * @param tableHandle Handle to the table.
+   * @return a new instance of LookupTableSize
    */
-  public <T extends TNumber, U extends TType> ResourceScatterDiv resourceScatterDiv(
-      Operand<?> resource, Operand<T> indices, Operand<U> updates) {
-    return ResourceScatterDiv.create(scope, resource, indices, updates);
+  public LookupTableSize lookupTableSize(Operand<?> tableHandle) {
+    return LookupTableSize.create(scope, tableHandle);
   }
 
   /**
-   * Reduces sparse updates into the variable referenced by `resource` using the `max` operation.
-   *  <p>
-   *  This operation computes
-   *  <p>
-   *      # Scalar indices
-   *      ref[indices, ...] = max(ref[indices, ...], updates[...])
-   *  <p>
-   *      # Vector indices (for each i)
-   *      ref[indices[i], ...] = max(ref[indices[i], ...], updates[i, ...])
-   *  <p>
-   *      # High rank indices (for each i, ..., j)
-   *      ref[indices[i, ..., j], ...] = max(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
-   *  <p>
-   *  Duplicate entries are handled correctly: if multiple `indices` reference
-   *  the same location, their contributions are combined.
-   *  <p>
-   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+   * Forwards the input to the output.
    *  <p>
-   *  <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>
+   *  This operator represents the loop termination condition used by the
+   *  "pivot" switches of a loop.
    *
-   * @param resource Should be from a `Variable` node.
-   * @param indices A tensor of indices into the first dimension of `ref`.
-   * @param updates A tensor of updated values to add to `ref`.
-   * @return a new instance of ResourceScatterMax
+   * @param input A boolean scalar, representing the branch predicate of the Switch op.
+   * @return a new instance of LoopCond
    */
-  public <T extends TNumber, U extends TType> ResourceScatterMax resourceScatterMax(
-      Operand<?> resource, Operand<T> indices, Operand<U> updates) {
-    return ResourceScatterMax.create(scope, resource, indices, updates);
+  public LoopCond loopCond(Operand<TBool> input) {
+    return LoopCond.create(scope, input);
   }
 
   /**
-   * Reduces sparse updates into the variable referenced by `resource` using the `min` operation.
-   *  <p>
-   *  This operation computes
-   *  <p>
-   *      # Scalar indices
-   *      ref[indices, ...] = min(ref[indices, ...], updates[...])
-   *  <p>
-   *      # Vector indices (for each i)
-   *      ref[indices[i], ...] = min(ref[indices[i], ...], updates[i, ...])
-   *  <p>
-   *      # High rank indices (for each i, ..., j)
-   *      ref[indices[i, ..., j], ...] = min(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
-   *  <p>
-   *  Duplicate entries are handled correctly: if multiple `indices` reference
-   *  the same location, their contributions are combined.
-   *  <p>
-   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
-   *  <p>
-   *  <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>
+   * Op removes all elements in the underlying container.
    *
-   * @param resource Should be from a `Variable` node.
-   * @param indices A tensor of indices into the first dimension of `ref`.
-   * @param updates A tensor of updated values to add to `ref`.
-   * @return a new instance of ResourceScatterMin
+   * @param dtypes
+   * @param options carries optional attributes values
+   * @return a new instance of MapClear
    */
-  public <T extends TNumber, U extends TType> ResourceScatterMin resourceScatterMin(
-      Operand<?> resource, Operand<T> indices, Operand<U> updates) {
-    return ResourceScatterMin.create(scope, resource, indices, updates);
+  public MapClear mapClear(List<DataType<?>> dtypes, MapClear.Options... options) {
+    return MapClear.create(scope, dtypes, options);
   }
 
   /**
-   * Multiplies sparse updates into the variable referenced by `resource`.
-   *  <p>
-   *  This operation computes
-   *  <p>
-   *      # Scalar indices
-   *      ref[indices, ...] *= updates[...]
-   *  <p>
-   *      # Vector indices (for each i)
-   *      ref[indices[i], ...] *= updates[i, ...]
-   *  <p>
-   *      # High rank indices (for each i, ..., j)
-   *      ref[indices[i, ..., j], ...] *= updates[i, ..., j, ...]
-   *  <p>
-   *  Duplicate entries are handled correctly: if multiple `indices` reference
-   *  the same location, their contributions multiply.
-   *  <p>
-   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
-   *  <p>
-   *  <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>
+   * Op returns the number of incomplete elements in the underlying container.
    *
-   * @param resource Should be from a `Variable` node.
-   * @param indices A tensor of indices into the first dimension of `ref`.
-   * @param updates A tensor of updated values to add to `ref`.
-   * @return a new instance of ResourceScatterMul
+   * @param dtypes
+   * @param options carries optional attributes values
+   * @return a new instance of MapIncompleteSize
    */
-  public <T extends TNumber, U extends TType> ResourceScatterMul resourceScatterMul(
-      Operand<?> resource, Operand<T> indices, Operand<U> updates) {
-    return ResourceScatterMul.create(scope, resource, indices, updates);
+  public MapIncompleteSize mapIncompleteSize(List<DataType<?>> dtypes,
+      MapIncompleteSize.Options... options) {
+    return MapIncompleteSize.create(scope, dtypes, options);
   }
 
   /**
-   * Applies sparse addition to individual values or slices in a Variable.
-   *  <p>
-   *  `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
-   *  <p>
-   *  `indices` must be integer tensor, containing indices into `ref`.
-   *  It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
-   *  <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`.
-   *  <p>
-   *  `updates` is `Tensor` of rank `Q-1+P-K` with shape:
-   *  <pre>{@code
-   *  [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]]
-   *  }</pre>
-   *  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:
-   *  <pre>{@code
-   *  ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8], use_resource=True)
-   *  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)
-   *  }</pre>
-   *  The resulting update to ref would look like this:
-   *  <p>
-   *      [1, 13, 3, 14, 14, 6, 7, 20]
+   * Op peeks at the values at the specified key.  If the
    *  <p>
-   *  See `tf.scatter_nd` for more details about how to make updates to
-   *  slices.
+   *  underlying container does not contain this key
+   *  this op will block until it does.
    *
-   * @param ref A resource handle. Must be from a VarHandleOp.
-   * @param indices A Tensor. Must be one of the following types: int32, int64.
-   *  A tensor of indices into ref.
-   * @param updates A Tensor. Must have the same type as ref. A tensor of
-   *  values to add to ref.
+   * @param key
+   * @param indices
+   * @param dtypes
    * @param options carries optional attributes values
-   * @return a new instance of ResourceScatterNdAdd
+   * @return a new instance of MapPeek
    */
-  public <T extends TNumber, U extends TType> ResourceScatterNdAdd resourceScatterNdAdd(
-      Operand<?> ref, Operand<T> indices, Operand<U> updates,
-      ResourceScatterNdAdd.Options... options) {
-    return ResourceScatterNdAdd.create(scope, ref, indices, updates, options);
+  public MapPeek mapPeek(Operand<TInt64> key, Operand<TInt32> indices, List<DataType<?>> dtypes,
+      MapPeek.Options... options) {
+    return MapPeek.create(scope, key, indices, dtypes, options);
   }
 
   /**
-   * Applies sparse subtraction to individual values or slices in a Variable.
-   *  <p>
-   *  `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
-   *  <p>
-   *  `indices` must be integer tensor, containing indices into `ref`.
-   *  It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
-   *  <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`.
-   *  <p>
-   *  `updates` is `Tensor` of rank `Q-1+P-K` with shape:
-   *  <pre>{@code
-   *  [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]]
-   *  }</pre>
-   *  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:
-   *  <pre>{@code
-   *  ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8], use_resource=True)
-   *  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)
-   *  }</pre>
-   *  The resulting update to ref would look like this:
-   *  <p>
-   *      [1, -9, 3, -6, -4, 6, 7, -4]
-   *  <p>
-   *  See `tf.scatter_nd` for more details about how to make updates to
-   *  slices.
+   * Op returns the number of elements in the underlying container.
    *
-   * @param ref A resource handle. Must be from a VarHandleOp.
-   * @param indices A Tensor. Must be one of the following types: int32, int64.
-   *  A tensor of indices into ref.
-   * @param updates A Tensor. Must have the same type as ref. A tensor of
-   *  values to add to ref.
+   * @param dtypes
    * @param options carries optional attributes values
-   * @return a new instance of ResourceScatterNdSub
+   * @return a new instance of MapSize
    */
-  public <T extends TNumber, U extends TType> ResourceScatterNdSub resourceScatterNdSub(
-      Operand<?> ref, Operand<T> indices, Operand<U> updates,
-      ResourceScatterNdSub.Options... options) {
-    return ResourceScatterNdSub.create(scope, ref, indices, updates, options);
+  public MapSize mapSize(List<DataType<?>> dtypes, MapSize.Options... options) {
+    return MapSize.create(scope, dtypes, options);
   }
 
   /**
-   * Applies sparse `updates` to individual values or slices within a given
-   *  <p>
-   *  variable according to `indices`.
-   *  <p>
-   *  `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
-   *  <p>
-   *  `indices` must be integer tensor, containing indices into `ref`.
-   *  It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
-   *  <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`.
-   *  <p>
-   *  `updates` is `Tensor` of rank `Q-1+P-K` with shape:
-   *  <pre>{@code
-   *  [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
-   *  }</pre>
-   *  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:
-   *  <pre>{@code
-   *      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)
-   *  }</pre>
-   *  The resulting update to ref would look like this:
-   *  <p>
-   *      [1, 11, 3, 10, 9, 6, 7, 12]
-   *  <p>
-   *  See `tf.scatter_nd` for more details about how to make updates to
-   *  slices.
+   * Stage (key, values) in the underlying container which behaves like a hashtable.
    *
-   * @param ref A resource handle. Must be from a VarHandleOp.
-   * @param indices A Tensor. Must be one of the following types: int32, int64.
-   *  A tensor of indices into ref.
-   * @param updates A Tensor. Must have the same type as ref. A tensor of updated
-   *  values to add to ref.
+   * @param key int64
+   * @param indices
+   * @param values a list of tensors
+   *  dtypes A list of data types that inserted values should adhere to.
+   * @param dtypes
    * @param options carries optional attributes values
-   * @return a new instance of ResourceScatterNdUpdate
+   * @return a new instance of MapStage
    */
-  public <T extends TNumber, U extends TType> ResourceScatterNdUpdate resourceScatterNdUpdate(
-      Operand<?> ref, Operand<T> indices, Operand<U> updates,
-      ResourceScatterNdUpdate.Options... options) {
-    return ResourceScatterNdUpdate.create(scope, ref, indices, updates, options);
+  public MapStage mapStage(Operand<TInt64> key, Operand<TInt32> indices,
+      Iterable<Operand<?>> values, List<DataType<?>> dtypes, MapStage.Options... options) {
+    return MapStage.create(scope, key, indices, values, dtypes, options);
   }
 
   /**
-   * Subtracts sparse updates from the variable referenced by `resource`.
-   *  <p>
-   *  This operation computes
-   *  <p>
-   *      # Scalar indices
-   *      ref[indices, ...] -= updates[...]
-   *  <p>
-   *      # Vector indices (for each i)
-   *      ref[indices[i], ...] -= updates[i, ...]
-   *  <p>
-   *      # High rank indices (for each i, ..., j)
-   *      ref[indices[i, ..., j], ...] -= updates[i, ..., j, ...]
-   *  <p>
-   *  Duplicate entries are handled correctly: if multiple `indices` reference
-   *  the same location, their contributions add.
-   *  <p>
-   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+   * Op removes and returns the values associated with the key
    *  <p>
-   *  <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>
+   *  from the underlying container.   If the underlying container
+   *  does not contain this key, the op will block until it does.
    *
-   * @param resource Should be from a `Variable` node.
-   * @param indices A tensor of indices into the first dimension of `ref`.
-   * @param updates A tensor of updated values to add to `ref`.
-   * @return a new instance of ResourceScatterSub
+   * @param key
+   * @param indices
+   * @param dtypes
+   * @param options carries optional attributes values
+   * @return a new instance of MapUnstage
    */
-  public <T extends TNumber, U extends TType> ResourceScatterSub resourceScatterSub(
-      Operand<?> resource, Operand<T> indices, Operand<U> updates) {
-    return ResourceScatterSub.create(scope, resource, indices, updates);
+  public MapUnstage mapUnstage(Operand<TInt64> key, Operand<TInt32> indices,
+      List<DataType<?>> dtypes, MapUnstage.Options... options) {
+    return MapUnstage.create(scope, key, indices, dtypes, options);
   }
 
   /**
-   * Assigns sparse updates to the variable referenced by `resource`.
-   *  <p>
-   *  This operation computes
-   *  <p>
-   *      # Scalar indices
-   *      ref[indices, ...] = updates[...]
-   *  <p>
-   *      # Vector indices (for each i)
-   *      ref[indices[i], ...] = updates[i, ...]
+   * Op removes and returns a random (key, value)
    *  <p>
-   *      # High rank indices (for each i, ..., j)
-   *      ref[indices[i, ..., j], ...] = updates[i, ..., j, ...]
+   *  from the underlying container.   If the underlying container
+   *  does not contain elements, the op will block until it does.
    *
-   * @param resource Should be from a `Variable` node.
-   * @param indices A tensor of indices into the first dimension of `ref`.
-   * @param updates A tensor of updated values to add to `ref`.
-   * @return a new instance of ResourceScatterUpdate
+   * @param indices
+   * @param dtypes
+   * @param options carries optional attributes values
+   * @return a new instance of MapUnstageNoKey
    */
-  public <T extends TNumber, U extends TType> ResourceScatterUpdate resourceScatterUpdate(
-      Operand<?> resource, Operand<T> indices, Operand<U> updates) {
-    return ResourceScatterUpdate.create(scope, resource, indices, updates);
+  public MapUnstageNoKey mapUnstageNoKey(Operand<TInt32> indices, List<DataType<?>> dtypes,
+      MapUnstageNoKey.Options... options) {
+    return MapUnstageNoKey.create(scope, indices, dtypes, options);
   }
 
   /**
-   * Assign `value` to the sliced l-value reference of `ref`.
-   *  <p>
-   *  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`.
+   * Computes the maximum of elements across dimensions of a tensor.
    *  <p>
-   *  NOTE this op currently does not support broadcasting and so `value`'s
-   *  shape must be exactly the shape produced by the slice of `ref`.
+   *  Reduces `input` 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 are
+   *  retained with length 1.
    *
-   * @param ref
-   * @param begin
-   * @param end
-   * @param strides
-   * @param value
+   * @param <T> data type for {@code output()} output
+   * @param input The tensor to reduce.
+   * @param axis The dimensions to reduce. Must be in the range
+   *  `[-rank(input), rank(input))`.
    * @param options carries optional attributes values
-   * @return a new instance of ResourceStridedSliceAssign
+   * @return a new instance of Max
    */
-  public <T extends TNumber, U extends TType> ResourceStridedSliceAssign resourceStridedSliceAssign(
-      Operand<?> ref, Operand<T> begin, Operand<T> end, Operand<T> strides, Operand<U> value,
-      ResourceStridedSliceAssign.Options... options) {
-    return ResourceStridedSliceAssign.create(scope, ref, begin, end, strides, value, options);
+  public <T extends TType, U extends TNumber> Max<T> max(Operand<T> input, Operand<U> axis,
+      Max.Options... options) {
+    return Max.create(scope, input, axis, options);
   }
 
   /**
-   * Reverses specific dimensions of a tensor.
-   *  <p>
-   *  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.
-   *  <p>
-   *  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`.
+   * Forwards the value of an available tensor from `inputs` to `output`.
    *  <p>
-   *  `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.
+   *  `Merge` waits for at least one of the tensors in `inputs` to become available.
+   *  It is usually combined with `Switch` to implement branching.
    *  <p>
-   *  For example:
-   *  <pre>{@code
-   *  # 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]]]]
+   *  `Merge` forwards the first tensor to become available to `output`, and sets
+   *  `value_index` to its index in `inputs`.
    *
-   *  # '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]]]]
-   *  }</pre>
+   * @param <T> data type for {@code output()} output
+   * @param inputs The input tensors, exactly one of which will become available.
+   * @return a new instance of Merge
+   */
+  public <T extends TType> Merge<T> merge(Iterable<Operand<T>> inputs) {
+    return Merge.create(scope, inputs);
+  }
+
+  /**
+   * Computes the minimum of elements across dimensions of a tensor.
+   *  <p>
+   *  Reduces `input` 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 are
+   *  retained with length 1.
    *
    * @param <T> data type for {@code output()} output
-   * @param tensor Up to 8-D.
-   * @param axis 1-D. The indices of the dimensions to reverse. Must be in the range
-   *  `[-rank(tensor), rank(tensor))`.
-   * @return a new instance of Reverse
+   * @param input The tensor to reduce.
+   * @param axis The dimensions to reduce. Must be in the range
+   *  `[-rank(input), rank(input))`.
+   * @param options carries optional attributes values
+   * @return a new instance of Min
    */
-  public <T extends TType, U extends TNumber> Reverse<T> reverse(Operand<T> tensor,
-      Operand<U> axis) {
-    return Reverse.create(scope, tensor, axis);
+  public <T extends TType, U extends TNumber> Min<T> min(Operand<T> input, Operand<U> axis,
+      Min.Options... options) {
+    return Min.create(scope, input, axis, options);
   }
 
   /**
-   * Reverses variable length slices.
+   * Pads a tensor with mirrored values.
    *  <p>
-   *  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`.
+   *  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).
    *  <p>
-   *  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 padded size of each dimension D of the output is:
    *  <p>
-   *  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.
+   *  `paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
    *  <p>
    *  For example:
    *  <pre>{@code
-   *  # 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:, :, ...]
-   *  }</pre>
-   *  In contrast, if:
-   *  <pre>{@code
-   *  # 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, :, ...]
+   *  # '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]]
    *  }</pre>
    *
    * @param <T> data type for {@code output()} output
-   * @param input The input to reverse.
-   * @param seqLengths 1-D with length `input.dims(batch_dim)` and
-   *  `max(seq_lengths) <= input.dims(seq_dim)`
-   * @param seqDim The dimension which is partially reversed.
-   * @param options carries optional attributes values
-   * @return a new instance of ReverseSequence
+   * @param input The input tensor to be padded.
+   * @param paddings A two-column matrix specifying the padding sizes. The number of
+   *  rows must be the same as the rank of `input`.
+   * @param mode 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.
+   * @return a new instance of MirrorPad
    */
-  public <T extends TType, U extends TNumber> ReverseSequence<T> reverseSequence(Operand<T> input,
-      Operand<U> seqLengths, Long seqDim, ReverseSequence.Options... options) {
-    return ReverseSequence.create(scope, input, seqLengths, seqDim, options);
+  public <T extends TType, U extends TNumber> MirrorPad<T> mirrorPad(Operand<T> input,
+      Operand<U> paddings, String mode) {
+    return MirrorPad.create(scope, input, paddings, mode);
   }
 
   /**
-   * Rolls the elements of a tensor along an axis.
-   *  <p>
-   *  The elements are shifted positively (towards larger indices) by the offset of
-   *  `shift` along the dimension of `axis`. Negative `shift` values will shift
-   *  elements in the opposite direction. Elements that roll passed the last position
-   *  will wrap around to the first and vice versa. Multiple shifts along multiple
-   *  axes may be specified.
+   * Wraps an arbitrary MLIR computation expressed as a module with a main() function.
    *  <p>
-   *  For example:
+   *  This operation does not have an associated kernel and is not intended to be
+   *  executed in a regular TensorFlow session. Instead it is intended to be used for
+   *  testing or for special case where a user intends to pass custom MLIR computation
+   *  through a TensorFlow graph with the intent of having custom tooling processing
+   *  it downstream (when targeting a different environment, like TensorFlow lite for
+   *  example).
+   *  The MLIR module is expected to have a main() function that will be used as an
+   *  entry point. The inputs to the operations will be passed as argument to the
+   *  main() function and the returned values of the main function mapped to the
+   *  outputs.
+   *  Example usage:
    *  <pre>{@code
-   *  # 't' is [0, 1, 2, 3, 4]
-   *  roll(t, shift=2, axis=0) ==> [3, 4, 0, 1, 2]
+   *  import tensorflow as tf
+   *  from tensorflow.compiler.mlir.tensorflow.gen_mlir_passthrough_op import mlir_passthrough_op
    *
-   *  # shifting along multiple dimensions
-   *  # 't' is [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
-   *  roll(t, shift=[1, -2], axis=[0, 1]) ==> [[7, 8, 9, 5, 6], [2, 3, 4, 0, 1]]
+   *  mlir_module = '''python
+   *  func @main(%arg0 : tensor<10xf32>, %arg1 : tensor<10xf32>) -> tensor<10x10xf32> {
+   *     %add = "magic.op"(%arg0, %arg1) : (tensor<10xf32>, tensor<10xf32>) -> tensor<10x10xf32>
+   *     return %ret : tensor<10x10xf32>
+   *  }
+   *  '''
    *
-   *  # shifting along the same axis multiple times
-   *  # 't' is [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
-   *  roll(t, shift=[2, -3], axis=[1, 1]) ==> [[1, 2, 3, 4, 0], [6, 7, 8, 9, 5]]
-   *  }</pre>
+   * @tf.function def foo(x, y):
+   *    return = mlir_passthrough_op([x, y], mlir_module, Toutputs=[tf.float32])
    *
-   * @param <T> data type for {@code output()} output
-   * @param input
-   * @param shift Dimension must be 0-D or 1-D. `shift[i]` specifies the number of places by which
-   *  elements are shifted positively (towards larger indices) along the dimension
-   *  specified by `axis[i]`. Negative shifts will roll the elements in the opposite
-   *  direction.
-   * @param axis Dimension must be 0-D or 1-D. `axis[i]` specifies the dimension that the shift
-   *  `shift[i]` should occur. If the same axis is referenced more than once, the
-   *  total shift for that axis will be the sum of all the shifts that belong to that
-   *  axis.
-   * @return a new instance of Roll
+   *  graph_def = foo.get_concrete_function(tf.TensorSpec([10], tf.float32), tf.TensorSpec([10], tf.float32)).graph.as_graph_def()
+   *  }</pre>
+   * @param inputs
+   * @param mlirModule
+   * @param Toutputs
+   * @return a new instance of MlirPassthroughOp
    */
-  public <T extends TType, U extends TNumber, V extends TNumber> Roll<T> roll(Operand<T> input,
-      Operand<U> shift, Operand<V> axis) {
-    return Roll.create(scope, input, shift, axis);
+  public MlirPassthroughOp mlirPassthroughOp(Iterable<Operand<?>> inputs, String mlirModule,
+      List<DataType<?>> Toutputs) {
+    return MlirPassthroughOp.create(scope, inputs, mlirModule, Toutputs);
   }
 
   /**
-   * Perform batches of RPC requests.
-   *  <p>
-   *  This op asynchronously performs either a single RPC request, or a batch
-   *  of requests.  RPC requests are defined by three main parameters:
-   *  <p>
-   *    - `address` (the host+port or BNS address of the request)
-   *    - `method` (the RPC method name for the request)
-   *    - `request` (the serialized proto string, or vector of strings,
-   *       of the RPC request argument).
-   *  <p>
-   *  For example, if you have an RPC service running on port localhost:2345,
-   *  and its interface is configured with the following proto declaration:
-   *  <pre>{@code
-   *  service MyService {
-   *    rpc MyMethod(MyRequestProto) returns (MyResponseProto) {
-   *    }
-   *  };
-   *  }</pre>
-   *  then call this op with arguments:
-   *  <pre>{@code
-   *  address = "localhost:2345"
-   *  method = "MyService/MyMethod"
-   *  }</pre>
-   *  The `request` tensor is a string tensor representing serialized `MyRequestProto`
-   *  strings; and the output string tensor `response` will have the same shape
-   *  and contain (upon successful completion) corresponding serialized
-   *  `MyResponseProto` strings.
-   *  <p>
-   *  For example, to send a single, empty, `MyRequestProto`, call
-   *  this op with `request = ""`.  To send 5 <b>parallel</b> empty requests,
-   *  call this op with `request = ["", "", "", "", ""]`.
-   *  <p>
-   *  More generally, one can create a batch of `MyRequestProto` serialized protos
-   *  from regular batched tensors using the `encode_proto` op, and convert
-   *  the response `MyResponseProto` serialized protos to batched tensors
-   *  using the `decode_proto` op.
-   *  <p>
-   *  <b>NOTE</b> Working with serialized proto strings is faster than instantiating
-   *  actual proto objects in memory, so no performance degradation is expected
-   *  compared to writing custom kernels for this workflow.
+   * Creates an empty hash table that uses tensors as the backing store.
    *  <p>
-   *  If the connection fails or the remote worker returns an error
-   *  status, the op reraises this exception locally.
+   *  It uses "open addressing" with quadratic reprobing to resolve
+   *  collisions.
    *  <p>
-   *  See the `TryRpc` op if you prefer to handle RPC failures manually in the graph.
+   *  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.
    *
-   * @param address `0-D` or `1-D`.  The address (i.e. host_name:port) of the RPC server.
-   *  If this tensor has more than 1 element, then multiple parallel rpc requests
-   *  are sent.  This argument broadcasts with `method` and `request`.
-   * @param method `0-D` or `1-D`.  The method address on the RPC server.
-   *  If this tensor has more than 1 element, then multiple parallel rpc requests
-   *  are sent.  This argument broadcasts with `address` and `request`.
-   * @param request `0-D` or `1-D`.  Serialized proto strings: the rpc request argument.
-   *  If this tensor has more than 1 element, then multiple parallel rpc requests
-   *  are sent.  This argument broadcasts with `address` and `method`.
+   * @param emptyKey The key used to represent empty key buckets internally. Must not
+   *  be used in insert or lookup operations.
+   * @param deletedKey
+   * @param valueDtype Type of the table values.
    * @param options carries optional attributes values
-   * @return a new instance of Rpc
+   * @return a new instance of MutableDenseHashTable
    */
-  public Rpc rpc(Operand<TString> address, Operand<TString> method, Operand<TString> request,
-      Rpc.Options... options) {
-    return Rpc.create(scope, address, method, request, options);
+  public <T extends TType, U extends TType> MutableDenseHashTable mutableDenseHashTable(
+      Operand<T> emptyKey, Operand<T> deletedKey, DataType<U> valueDtype,
+      MutableDenseHashTable.Options... options) {
+    return MutableDenseHashTable.create(scope, emptyKey, deletedKey, valueDtype, options);
   }
 
   /**
-   * Adds sparse updates to a variable reference.
-   *  <p>
-   *  This operation computes
-   *  <p>
-   *      # Scalar indices
-   *      ref[indices, ...] += updates[...]
-   *  <p>
-   *      # Vector indices (for each i)
-   *      ref[indices[i], ...] += updates[i, ...]
-   *  <p>
-   *      # High rank indices (for each i, ..., j)
-   *      ref[indices[i, ..., j], ...] += updates[i, ..., j, ...]
-   *  <p>
-   *  This operation outputs `ref` after the update is done.
-   *  This makes it easier to chain operations that need to use the reset value.
-   *  <p>
-   *  Duplicate entries are handled correctly: if multiple `indices` reference
-   *  the same location, their contributions add.
-   *  <p>
-   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+   * Creates an empty hash table.
    *  <p>
-   *  <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>
+   *  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.
    *
-   * @param <T> data type for {@code outputRef()} output
-   * @param ref Should be from a `Variable` node.
-   * @param indices A tensor of indices into the first dimension of `ref`.
-   * @param updates A tensor of updated values to add to `ref`.
+   * @param keyDtype Type of the table keys.
+   * @param valueDtype Type of the table values.
    * @param options carries optional attributes values
-   * @return a new instance of ScatterAdd
+   * @return a new instance of MutableHashTable
    */
-  public <T extends TType, U extends TNumber> ScatterAdd<T> scatterAdd(Operand<T> ref,
-      Operand<U> indices, Operand<T> updates, ScatterAdd.Options... options) {
-    return ScatterAdd.create(scope, ref, indices, updates, options);
+  public <T extends TType, U extends TType> MutableHashTable mutableHashTable(DataType<T> keyDtype,
+      DataType<U> valueDtype, MutableHashTable.Options... options) {
+    return MutableHashTable.create(scope, keyDtype, valueDtype, options);
   }
 
   /**
-   * Divides a variable reference by sparse updates.
+   * Creates an empty hash table.
    *  <p>
-   *  This operation computes
-   *  <pre>{@code
-   *      # Scalar indices
-   *      ref[indices, ...] /= updates[...]
-   *
-   *      # Vector indices (for each i)
-   *      ref[indices[i], ...] /= updates[i, ...]
+   *  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.
    *
-   *      # High rank indices (for each i, ..., j)
-   *      ref[indices[i, ..., j], ...] /= updates[i, ..., j, ...]
-   *  }</pre>
-   *  This operation outputs `ref` after the update is done.
-   *  This makes it easier to chain operations that need to use the reset value.
-   *  <p>
-   *  Duplicate entries are handled correctly: if multiple `indices` reference
-   *  the same location, their contributions divide.
-   *  <p>
-   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
-   *
-   * @param <T> data type for {@code outputRef()} output
-   * @param ref Should be from a `Variable` node.
-   * @param indices A tensor of indices into the first dimension of `ref`.
-   * @param updates A tensor of values that `ref` is divided by.
+   * @param keyDtype Type of the table keys.
+   * @param valueDtype Type of the table values.
    * @param options carries optional attributes values
-   * @return a new instance of ScatterDiv
+   * @return a new instance of MutableHashTableOfTensors
    */
-  public <T extends TType, U extends TNumber> ScatterDiv<T> scatterDiv(Operand<T> ref,
-      Operand<U> indices, Operand<T> updates, ScatterDiv.Options... options) {
-    return ScatterDiv.create(scope, ref, indices, updates, options);
+  public <T extends TType, U extends TType> MutableHashTableOfTensors mutableHashTableOfTensors(
+      DataType<T> keyDtype, DataType<U> valueDtype, MutableHashTableOfTensors.Options... options) {
+    return MutableHashTableOfTensors.create(scope, keyDtype, valueDtype, options);
   }
 
   /**
-   * Reduces sparse updates into a variable reference using the `max` operation.
-   *  <p>
-   *  This operation computes
-   *  <p>
-   *      # Scalar indices
-   *      ref[indices, ...] = max(ref[indices, ...], updates[...])
-   *  <p>
-   *      # Vector indices (for each i)
-   *      ref[indices[i], ...] = max(ref[indices[i], ...], updates[i, ...])
-   *  <p>
-   *      # High rank indices (for each i, ..., j)
-   *      ref[indices[i, ..., j], ...] = max(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
-   *  <p>
-   *  This operation outputs `ref` after the update is done.
-   *  This makes it easier to chain operations that need to use the reset value.
-   *  <p>
-   *  Duplicate entries are handled correctly: if multiple `indices` reference
-   *  the same location, their contributions combine.
-   *  <p>
-   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
-   *  <p>
-   *  <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>
+   * Creates a Mutex resource that can be locked by `MutexLock`.
    *
-   * @param <T> data type for {@code outputRef()} output
-   * @param ref Should be from a `Variable` node.
-   * @param indices A tensor of indices into the first dimension of `ref`.
-   * @param updates A tensor of updated values to reduce into `ref`.
    * @param options carries optional attributes values
-   * @return a new instance of ScatterMax
+   * @return a new instance of Mutex
    */
-  public <T extends TNumber, U extends TNumber> ScatterMax<T> scatterMax(Operand<T> ref,
-      Operand<U> indices, Operand<T> updates, ScatterMax.Options... options) {
-    return ScatterMax.create(scope, ref, indices, updates, options);
+  public Mutex mutex(Mutex.Options... options) {
+    return Mutex.create(scope, options);
   }
 
   /**
-   * Reduces sparse updates into a variable reference using the `min` operation.
-   *  <p>
-   *  This operation computes
-   *  <p>
-   *      # Scalar indices
-   *      ref[indices, ...] = min(ref[indices, ...], updates[...])
-   *  <p>
-   *      # Vector indices (for each i)
-   *      ref[indices[i], ...] = min(ref[indices[i], ...], updates[i, ...])
-   *  <p>
-   *      # High rank indices (for each i, ..., j)
-   *      ref[indices[i, ..., j], ...] = min(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
+   * Locks a mutex resource.  The output is the lock.  So long as the lock tensor
    *  <p>
-   *  This operation outputs `ref` after the update is done.
-   *  This makes it easier to chain operations that need to use the reset value.
+   *  is alive, any other request to use `MutexLock` with this mutex will wait.
    *  <p>
-   *  Duplicate entries are handled correctly: if multiple `indices` reference
-   *  the same location, their contributions combine.
+   *  This is particularly useful for creating a critical section when used in
+   *  conjunction with `MutexLockIdentity`:
+   *  <pre>{@code
+   *  mutex = mutex_v2(
+   *    shared_name=handle_name, container=container, name=name)
+   *
+   *  def execute_in_critical_section(fn, *args, **kwargs):
+   *    lock = gen_resource_variable_ops.mutex_lock(mutex)
+   *
+   *    with ops.control_dependencies([lock]):
+   *      r = fn(*args, **kwargs)
+   *
+   *    with ops.control_dependencies(nest.flatten(r)):
+   *      with ops.colocate_with(mutex):
+   *        ensure_lock_exists = mutex_lock_identity(lock)
+   *
+   *      # Make sure that if any element of r is accessed, all of
+   *      # them are executed together.
+   *      r = nest.map_structure(tf.identity, r)
+   *
+   *    with ops.control_dependencies([ensure_lock_exists]):
+   *      return nest.map_structure(tf.identity, r)
+   *  }</pre>
+   *  While `fn` is running in the critical section, no other functions which wish to
+   *  use this critical section may run.
    *  <p>
-   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+   *  Often the use case is that two executions of the same graph, in parallel,
+   *  wish to run `fn`; and we wish to ensure that only one of them executes
+   *  at a time.  This is especially important if `fn` modifies one or more
+   *  variables at a time.
    *  <p>
-   *  <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>
+   *  It is also useful if two separate functions must share a resource, but we
+   *  wish to ensure the usage is exclusive.
    *
-   * @param <T> data type for {@code outputRef()} output
-   * @param ref Should be from a `Variable` node.
-   * @param indices A tensor of indices into the first dimension of `ref`.
-   * @param updates A tensor of updated values to reduce into `ref`.
-   * @param options carries optional attributes values
-   * @return a new instance of ScatterMin
+   * @param mutex The mutex resource to lock.
+   * @return a new instance of MutexLock
    */
-  public <T extends TNumber, U extends TNumber> ScatterMin<T> scatterMin(Operand<T> ref,
-      Operand<U> indices, Operand<T> updates, ScatterMin.Options... options) {
-    return ScatterMin.create(scope, ref, indices, updates, options);
+  public MutexLock mutexLock(Operand<?> mutex) {
+    return MutexLock.create(scope, mutex);
   }
 
   /**
-   * Multiplies sparse updates into a variable reference.
-   *  <p>
-   *  This operation computes
-   *  <pre>{@code
-   *      # Scalar indices
-   *      ref[indices, ...] *= updates[...]
-   *
-   *      # Vector indices (for each i)
-   *      ref[indices[i], ...] *= updates[i, ...]
+   * Makes its input available to the next iteration.
    *
-   *      # High rank indices (for each i, ..., j)
-   *      ref[indices[i, ..., j], ...] *= updates[i, ..., j, ...]
-   *  }</pre>
-   *  This operation outputs `ref` after the update is done.
-   *  This makes it easier to chain operations that need to use the reset value.
-   *  <p>
-   *  Duplicate entries are handled correctly: if multiple `indices` reference
-   *  the same location, their contributions multiply.
-   *  <p>
-   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+   * @param <T> data type for {@code output()} output
+   * @param data The tensor to be made available to the next iteration.
+   * @return a new instance of NextIteration
+   */
+  public <T extends TType> NextIteration<T> nextIteration(Operand<T> data) {
+    return NextIteration.create(scope, data);
+  }
+
+  /**
+   * Does nothing. Only useful as a placeholder for control edges.
    *
-   * @param <T> data type for {@code outputRef()} output
-   * @param ref Should be from a `Variable` node.
-   * @param indices A tensor of indices into the first dimension of `ref`.
-   * @param updates A tensor of updated values to multiply to `ref`.
-   * @param options carries optional attributes values
-   * @return a new instance of ScatterMul
+   * @return a new instance of NoOp
    */
-  public <T extends TType, U extends TNumber> ScatterMul<T> scatterMul(Operand<T> ref,
-      Operand<U> indices, Operand<T> updates, ScatterMul.Options... options) {
-    return ScatterMul.create(scope, ref, indices, updates, options);
+  public NoOp noOp() {
+    return NoOp.create(scope);
   }
 
   /**
-   * Scatter `updates` into a new tensor according to `indices`.
-   *  <p>
-   *  Creates a new tensor by applying sparse `updates` to individual values or
-   *  slices within a tensor (initially zero for numeric, empty for string) 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.
-   *  <p>
-   *  This operation is similar to tensor_scatter_add, except that the tensor is
-   *  zero-initialized. Calling `tf.scatter_nd(indices, values, shape)` is identical
-   *  to `tensor_scatter_add(tf.zeros(shape, values.dtype), indices, values)`
-   *  <p>
-   *  If `indices` contains duplicates, then their updates are accumulated (summed).
-   *  <p>
-   *  <b>WARNING</b>: The order in which updates are applied is nondeterministic, so the
-   *  output will be nondeterministic if `indices` contains duplicates -- because
-   *  of some numerical approximation issues, numbers summed in different order
-   *  may yield different results.
-   *  <p>
-   *  `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`:
-   *  <p>
-   *      indices.shape[-1] <= shape.rank
-   *  <p>
-   *  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
+   * Returns a one-hot tensor.
    *  <p>
-   *      indices.shape[:-1] + shape[indices.shape[-1]:]
+   *  The locations represented by indices in `indices` take value `on_value`,
+   *  while all other locations take value `off_value`.
    *  <p>
-   *  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.
+   *  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).
    *  <p>
-   *  <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>
+   *  If `indices` is a scalar the output shape will be a vector of length `depth`.
    *  <p>
-   *  In Python, this scatter operation would look like this:
+   *  If `indices` is a vector of length `features`, the output shape will be:
    *  <pre>{@code
-   *      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)
-   *      print(scatter)
+   *    features x depth if axis == -1
+   *    depth x features if axis == 0
    *  }</pre>
-   *  The resulting tensor would look like this:
-   *  <p>
-   *      [0, 11, 0, 10, 9, 0, 0, 12]
-   *  <p>
-   *  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.
-   *  <p>
-   *  <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>
-   *  <p>
-   *  In Python, this scatter operation would look like this:
+   *  If `indices` is a matrix (batch) with shape `[batch, features]`,
+   *  the output shape will be:
    *  <pre>{@code
-   *      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)
-   *      print(scatter)
+   *    batch x features x depth if axis == -1
+   *    batch x depth x features if axis == 1
+   *    depth x batch x features if axis == 0
    *  }</pre>
-   *  The resulting tensor would look like this:
-   *  <p>
-   *      [[[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]]]
+   *  Examples
+   *  =========
    *  <p>
-   *  Note that on CPU, if an out of bound index is found, an error is returned.
-   *  On GPU, if an out of bound index is found, the index is ignored.
-   *
-   * @param <U> data type for {@code output()} output
-   * @param indices Index tensor.
-   * @param updates Updates to scatter into output.
-   * @param shape 1-D. The shape of the resulting tensor.
-   * @return a new instance of ScatterNd
-   */
-  public <U extends TType, T extends TNumber> ScatterNd<U> scatterNd(Operand<T> indices,
-      Operand<U> updates, Operand<T> shape) {
-    return ScatterNd.create(scope, indices, updates, shape);
-  }
-
-  /**
-   * Applies sparse addition to individual values or slices in a Variable.
-   *  <p>
-   *  `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
-   *  <p>
-   *  `indices` must be integer tensor, containing indices into `ref`.
-   *  It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
-   *  <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`.
-   *  <p>
-   *  `updates` is `Tensor` of rank `Q-1+P-K` with shape:
+   *  Suppose that
    *  <pre>{@code
-   *  [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]]
+   *    indices = [0, 2, -1, 1]
+   *    depth = 3
+   *    on_value = 5.0
+   *    off_value = 0.0
+   *    axis = -1
    *  }</pre>
-   *  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:
+   *  Then output is `[4 x 3]`:
    *  <pre>{@code
-   *  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)
+   *  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)
+   *  }</pre>
+   *  Suppose that
+   *  <pre>{@code
+   *    indices = [0, 2, -1, 1]
+   *    depth = 3
+   *    on_value = 0.0
+   *    off_value = 3.0
+   *    axis = 0
+   *  }</pre>
+   *  Then output is `[3 x 4]`:
+   *  <pre>{@code
+   *  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)
+   *  }</pre>
+   *  Suppose that
+   *  <pre>{@code
+   *    indices = [[0, 2], [1, -1]]
+   *    depth = 3
+   *    on_value = 1.0
+   *    off_value = 0.0
+   *    axis = -1
+   *  }</pre>
+   *  Then output is `[2 x 2 x 3]`:
+   *  <pre>{@code
+   *  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)
+   *    ]
    *  }</pre>
-   *  The resulting update to ref would look like this:
-   *  <p>
-   *      [1, 13, 3, 14, 14, 6, 7, 20]
-   *  <p>
-   *  See `tf.scatter_nd` for more details about how to make updates to
-   *  slices.
    *
-   * @param <T> data type for {@code outputRef()} output
-   * @param ref A mutable Tensor. Should be from a Variable node.
-   * @param indices A Tensor. Must be one of the following types: int32, int64.
-   *  A tensor of indices into ref.
-   * @param updates A Tensor. Must have the same type as ref. A tensor of updated values
-   *  to add to ref.
+   * @param <U> data type for {@code output()} output
+   * @param indices A tensor of indices.
+   * @param depth A scalar defining the depth of the one hot dimension.
+   * @param onValue A scalar defining the value to fill in output when `indices[j] = i`.
+   * @param offValue A scalar defining the value to fill in output when `indices[j] != i`.
    * @param options carries optional attributes values
-   * @return a new instance of ScatterNdAdd
+   * @return a new instance of OneHot
    */
-  public <T extends TType, U extends TNumber> ScatterNdAdd<T> scatterNdAdd(Operand<T> ref,
-      Operand<U> indices, Operand<T> updates, ScatterNdAdd.Options... options) {
-    return ScatterNdAdd.create(scope, ref, indices, updates, options);
+  public <U extends TType, T extends TNumber> OneHot<U> oneHot(Operand<T> indices,
+      Operand<TInt32> depth, Operand<U> onValue, Operand<U> offValue, OneHot.Options... options) {
+    return OneHot.create(scope, indices, depth, onValue, offValue, options);
   }
 
   /**
-   * Applies sparse addition to `input` using individual values or slices
-   *  <p>
-   *  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`.
-   *  <p>
-   *  `input` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
-   *  <p>
-   *  `indices` must be integer tensor, containing indices into `input`.
-   *  It must be shape \\([d_0, ..., d_{Q-2}, K]\\) where `0 < K <= P`.
-   *  <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`.
-   *  <p>
-   *  `updates` is `Tensor` of rank `Q-1+P-K` with shape:
-   *  <p>
-   *  $$[d_0, ..., d_{Q-2}, input.shape[K], ..., input.shape[P-1]].$$
-   *  <p>
-   *  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:
-   *  <p>
-   *      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))
-   *  <p>
-   *  The resulting value `output` would look like this:
-   *  <p>
-   *      [1, 13, 3, 14, 14, 6, 7, 20]
-   *  <p>
-   *  See `tf.scatter_nd` for more details about how to make updates to slices.
+   * Returns a tensor of ones with the same shape and type as x.
    *
-   * @param <T> data type for {@code output()} output
-   * @param input A Tensor.
-   * @param indices A Tensor. Must be one of the following types: `int32`, `int64`.
-   *  A tensor of indices into `input`.
-   * @param updates A Tensor. Must have the same type as ref. A tensor of updated values
-   *  to add to `input`.
-   * @return a new instance of ScatterNdNonAliasingAdd
+   * @param <T> data type for {@code y()} output
+   * @param x a tensor of type T.
+   * @return a new instance of OnesLike
    */
-  public <T extends TType, U extends TNumber> ScatterNdNonAliasingAdd<T> scatterNdNonAliasingAdd(
-      Operand<T> input, Operand<U> indices, Operand<T> updates) {
-    return ScatterNdNonAliasingAdd.create(scope, input, indices, updates);
+  public <T extends TType> OnesLike<T> onesLike(Operand<T> x) {
+    return OnesLike.create(scope, x);
   }
 
   /**
-   * Applies sparse subtraction to individual values or slices in a Variable.
-   *  <p>
-   *  within a given variable according to `indices`.
-   *  <p>
-   *  `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
-   *  <p>
-   *  `indices` must be integer tensor, containing indices into `ref`.
-   *  It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
-   *  <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`.
-   *  <p>
-   *  `updates` is `Tensor` of rank `Q-1+P-K` with shape:
-   *  <pre>{@code
-   *  [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]]
-   *  }</pre>
-   *  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:
-   *  <pre>{@code
-   *  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)
-   *  }</pre>
-   *  The resulting update to ref would look like this:
-   *  <p>
-   *      [1, -9, 3, -6, -4, 6, 7, -4]
-   *  <p>
-   *  See `tf.scatter_nd` for more details about how to make updates to
-   *  slices.
+   * Op removes all elements in the underlying container.
    *
-   * @param <T> data type for {@code outputRef()} output
-   * @param ref A mutable Tensor. Should be from a Variable node.
-   * @param indices A Tensor. Must be one of the following types: int32, int64.
-   *  A tensor of indices into ref.
-   * @param updates A Tensor. Must have the same type as ref. A tensor of updated values
-   *  to subtract from ref.
+   * @param dtypes
    * @param options carries optional attributes values
-   * @return a new instance of ScatterNdSub
+   * @return a new instance of OrderedMapClear
    */
-  public <T extends TType, U extends TNumber> ScatterNdSub<T> scatterNdSub(Operand<T> ref,
-      Operand<U> indices, Operand<T> updates, ScatterNdSub.Options... options) {
-    return ScatterNdSub.create(scope, ref, indices, updates, options);
+  public OrderedMapClear orderedMapClear(List<DataType<?>> dtypes,
+      OrderedMapClear.Options... options) {
+    return OrderedMapClear.create(scope, dtypes, options);
   }
 
   /**
-   * Applies sparse `updates` to individual values or slices within a given
-   *  <p>
-   *  variable according to `indices`.
-   *  <p>
-   *  `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
-   *  <p>
-   *  `indices` must be integer tensor, containing indices into `ref`.
-   *  It must be shape \\([d_0, ..., d_{Q-2}, K]\\) where `0 < K <= P`.
-   *  <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`.
-   *  <p>
-   *  `updates` is `Tensor` of rank `Q-1+P-K` with shape:
-   *  <p>
-   *  $$[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].$$
-   *  <p>
-   *  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:
-   *  <pre>{@code
-   *      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)
-   *  }</pre>
-   *  The resulting update to ref would look like this:
-   *  <p>
-   *      [1, 11, 3, 10, 9, 6, 7, 12]
-   *  <p>
-   *  See `tf.scatter_nd` for more details about how to make updates to
-   *  slices.
-   *  <p>
-   *  See also `tf.scatter_update` and `tf.batch_scatter_update`.
+   * Op returns the number of incomplete elements in the underlying container.
    *
-   * @param <T> data type for {@code outputRef()} output
-   * @param ref A mutable Tensor. Should be from a Variable node.
-   * @param indices A Tensor. Must be one of the following types: int32, int64.
-   *  A tensor of indices into ref.
-   * @param updates A Tensor. Must have the same type as ref. A tensor of updated
-   *  values to add to ref.
+   * @param dtypes
    * @param options carries optional attributes values
-   * @return a new instance of ScatterNdUpdate
+   * @return a new instance of OrderedMapIncompleteSize
    */
-  public <T extends TType, U extends TNumber> ScatterNdUpdate<T> scatterNdUpdate(Operand<T> ref,
-      Operand<U> indices, Operand<T> updates, ScatterNdUpdate.Options... options) {
-    return ScatterNdUpdate.create(scope, ref, indices, updates, options);
-  }
-
-  /**
-   * Subtracts sparse updates to a variable reference.
-   *  <p>
-   *  <pre>{@code
-   *      # 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, ...]
-   *  }</pre>
-   *  This operation outputs `ref` after the update is done.
-   *  This makes it easier to chain operations that need to use the reset value.
-   *  <p>
-   *  Duplicate entries are handled correctly: if multiple `indices` reference
-   *  the same location, their (negated) contributions add.
-   *  <p>
-   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
-   *  <p>
-   *  <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>
-   *
-   * @param <T> data type for {@code outputRef()} output
-   * @param ref Should be from a `Variable` node.
-   * @param indices A tensor of indices into the first dimension of `ref`.
-   * @param updates A tensor of updated values to subtract from `ref`.
-   * @param options carries optional attributes values
-   * @return a new instance of ScatterSub
-   */
-  public <T extends TType, U extends TNumber> ScatterSub<T> scatterSub(Operand<T> ref,
-      Operand<U> indices, Operand<T> updates, ScatterSub.Options... options) {
-    return ScatterSub.create(scope, ref, indices, updates, options);
+  public OrderedMapIncompleteSize orderedMapIncompleteSize(List<DataType<?>> dtypes,
+      OrderedMapIncompleteSize.Options... options) {
+    return OrderedMapIncompleteSize.create(scope, dtypes, options);
   }
 
   /**
-   * Applies sparse updates to a variable reference.
-   *  <p>
-   *  This operation computes
-   *  <pre>{@code
-   *      # 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, ...]
-   *  }</pre>
-   *  This operation outputs `ref` after the update is done.
-   *  This makes it easier to chain operations that need to use the reset value.
-   *  <p>
-   *  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.
-   *  <p>
-   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
-   *  <p>
-   *  <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>
+   * Op peeks at the values at the specified key.  If the
    *  <p>
-   *  See also `tf.batch_scatter_update` and `tf.scatter_nd_update`.
+   *  underlying container does not contain this key
+   *  this op will block until it does.   This Op is optimized for
+   *  performance.
    *
-   * @param <T> data type for {@code outputRef()} output
-   * @param ref Should be from a `Variable` node.
-   * @param indices A tensor of indices into the first dimension of `ref`.
-   * @param updates A tensor of updated values to store in `ref`.
+   * @param key
+   * @param indices
+   * @param dtypes
    * @param options carries optional attributes values
-   * @return a new instance of ScatterUpdate
+   * @return a new instance of OrderedMapPeek
    */
-  public <T extends TType, U extends TNumber> ScatterUpdate<T> scatterUpdate(Operand<T> ref,
-      Operand<U> indices, Operand<T> updates, ScatterUpdate.Options... options) {
-    return ScatterUpdate.create(scope, ref, indices, updates, options);
+  public OrderedMapPeek orderedMapPeek(Operand<TInt64> key, Operand<TInt32> indices,
+      List<DataType<?>> dtypes, OrderedMapPeek.Options... options) {
+    return OrderedMapPeek.create(scope, key, indices, dtypes, options);
   }
 
   /**
+   * Op returns the number of elements in the underlying container.
    *
-   * @param <T> data type for {@code output()} output
-   * @param condition
-   * @param t
-   * @param e
-   * @return a new instance of Select
+   * @param dtypes
+   * @param options carries optional attributes values
+   * @return a new instance of OrderedMapSize
    */
-  public <T extends TType> Select<T> select(Operand<TBool> condition, Operand<T> t, Operand<T> e) {
-    return Select.create(scope, condition, t, e);
+  public OrderedMapSize orderedMapSize(List<DataType<?>> dtypes,
+      OrderedMapSize.Options... options) {
+    return OrderedMapSize.create(scope, dtypes, options);
   }
 
   /**
-   * Computes the difference between two lists of numbers or strings.
-   *  <p>
-   *  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:
-   *  <p>
-   *  `out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]`
+   * Stage (key, values) in the underlying container which behaves like a ordered
    *  <p>
-   *  For example, given this input:
-   *  <pre>{@code
-   *  x = [1, 2, 3, 4, 5, 6]
-   *  y = [1, 3, 5]
-   *  }</pre>
-   *  This operation would return:
-   *  <pre>{@code
-   *  out ==> [2, 4, 6]
-   *  idx ==> [1, 3, 5]
-   *  }</pre>
+   *  associative container.   Elements are ordered by key.
    *
-   * @param <T> data type for {@code out()} output
-   * @param <U> data type for {@code idx()} output
-   * @param x 1-D. Values to keep.
-   * @param y 1-D. Values to remove.
-   * @return a new instance of SetDiff1d
+   * @param key int64
+   * @param indices
+   * @param values a list of tensors
+   *  dtypes A list of data types that inserted values should adhere to.
+   * @param dtypes
+   * @param options carries optional attributes values
+   * @return a new instance of OrderedMapStage
    */
-  public <T extends TType> SetDiff1d<T, TInt32> setDiff1d(Operand<T> x, Operand<T> y) {
-    return SetDiff1d.create(scope, x, y);
+  public OrderedMapStage orderedMapStage(Operand<TInt64> key, Operand<TInt32> indices,
+      Iterable<Operand<?>> values, List<DataType<?>> dtypes, OrderedMapStage.Options... options) {
+    return OrderedMapStage.create(scope, key, indices, values, dtypes, options);
   }
 
   /**
-   * Computes the difference between two lists of numbers or strings.
-   *  <p>
-   *  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:
-   *  <p>
-   *  `out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]`
+   * Op removes and returns the values associated with the key
    *  <p>
-   *  For example, given this input:
-   *  <pre>{@code
-   *  x = [1, 2, 3, 4, 5, 6]
-   *  y = [1, 3, 5]
-   *  }</pre>
-   *  This operation would return:
-   *  <pre>{@code
-   *  out ==> [2, 4, 6]
-   *  idx ==> [1, 3, 5]
-   *  }</pre>
+   *  from the underlying container.   If the underlying container
+   *  does not contain this key, the op will block until it does.
    *
-   * @param <T> data type for {@code out()} output
-   * @param <U> data type for {@code idx()} output
-   * @param x 1-D. Values to keep.
-   * @param y 1-D. Values to remove.
-   * @param outIdx
-   * @return a new instance of SetDiff1d
+   * @param key
+   * @param indices
+   * @param dtypes
+   * @param options carries optional attributes values
+   * @return a new instance of OrderedMapUnstage
    */
-  public <T extends TType, U extends TNumber> SetDiff1d<T, U> setDiff1d(Operand<T> x, Operand<T> y,
-      DataType<U> outIdx) {
-    return SetDiff1d.create(scope, x, y, outIdx);
+  public OrderedMapUnstage orderedMapUnstage(Operand<TInt64> key, Operand<TInt32> indices,
+      List<DataType<?>> dtypes, OrderedMapUnstage.Options... options) {
+    return OrderedMapUnstage.create(scope, key, indices, dtypes, options);
   }
 
   /**
-   * Number of unique elements along last dimension of input `set`.
-   *  <p>
-   *  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.
+   * Op removes and returns the (key, value) element with the smallest
    *  <p>
-   *  If `validate_indices` is `True`, this op validates the order and range of `set`
-   *  indices.
+   *  key from the underlying container.   If the underlying container
+   *  does not contain elements, the op will block until it does.
    *
-   * @param setIndices 2D `Tensor`, indices of a `SparseTensor`.
-   * @param setValues 1D `Tensor`, values of a `SparseTensor`.
-   * @param setShape 1D `Tensor`, shape of a `SparseTensor`.
+   * @param indices
+   * @param dtypes
    * @param options carries optional attributes values
-   * @return a new instance of SetSize
+   * @return a new instance of OrderedMapUnstageNoKey
    */
-  public <T extends TType> SetSize setSize(Operand<TInt64> setIndices, Operand<T> setValues,
-      Operand<TInt64> setShape, SetSize.Options... options) {
-    return SetSize.create(scope, setIndices, setValues, setShape, options);
+  public OrderedMapUnstageNoKey orderedMapUnstageNoKey(Operand<TInt32> indices,
+      List<DataType<?>> dtypes, OrderedMapUnstageNoKey.Options... options) {
+    return OrderedMapUnstageNoKey.create(scope, indices, dtypes, options);
   }
 
   /**
-   * Returns the shape of a tensor.
+   * Pads a tensor.
    *  <p>
-   *  This operation returns a 1-D integer tensor representing the shape of `input`.
+   *  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`.
+   *  <p>
+   *  The padded size of each dimension D of the output is:
+   *  <p>
+   *  `paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
    *  <p>
    *  For example:
    *  <pre>{@code
-   *  # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
-   *  shape(t) ==> [2, 2, 3]
+   *  # '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]]
    *  }</pre>
    *
-   * @param <U> data type for {@code output()} output
+   * @param <T> data type for {@code output()} output
    * @param input
-   * @return a new instance of Shape
+   * @param paddings
+   * @param constantValues
+   * @return a new instance of Pad
    */
-  public <T extends TType> org.tensorflow.op.core.Shape<TInt32> shape(Operand<T> input) {
-    return org.tensorflow.op.core.Shape.create(scope, input);
+  public <T extends TType, U extends TNumber> Pad<T> pad(Operand<T> input, Operand<U> paddings,
+      Operand<T> constantValues) {
+    return Pad.create(scope, input, paddings, constantValues);
   }
 
   /**
-   * Returns the shape of a tensor.
+   * Concatenates a list of `N` tensors along the first dimension.
    *  <p>
-   *  This operation returns a 1-D integer tensor representing the shape of `input`.
+   *  The input tensors are all required to have size 1 in the first dimension.
    *  <p>
    *  For example:
    *  <pre>{@code
-   *  # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
-   *  shape(t) ==> [2, 2, 3]
+   *  # '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.
    *  }</pre>
+   *  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.
    *
-   * @param <U> data type for {@code output()} output
-   * @param input
-   * @param outType
-   * @return a new instance of Shape
-   */
-  public <U extends TNumber, T extends TType> org.tensorflow.op.core.Shape<U> shape(
-      Operand<T> input, DataType<U> outType) {
-    return org.tensorflow.op.core.Shape.create(scope, input, outType);
-  }
+   * @param <T> data type for {@code output()} output
+   * @param values Tensors to be concatenated. All must have size 1 in the first dimension
+   *  and same shape.
+   * @param shape 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.
+   * @return a new instance of ParallelConcat
+   */
+  public <T extends TType> ParallelConcat<T> parallelConcat(Iterable<Operand<T>> values,
+      Shape shape) {
+    return ParallelConcat.create(scope, values, shape);
+  }
 
   /**
-   * Returns shape of tensors.
+   * Interleave the values from the `data` tensors into a single tensor.
    *  <p>
-   *  This operation returns N 1-D integer tensors representing shape of `input[i]s`.
+   *  Builds a merged tensor such that
+   *  <pre>{@code
+   *      merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]
+   *  }</pre>
+   *  For example, if each `indices[m]` is scalar or vector, we have
+   *  <pre>{@code
+   *      # Scalar indices:
+   *      merged[indices[m], ...] = data[m][...]
    *
-   * @param <U> data type for {@code output()} output
-   * @param input
-   * @return a new instance of ShapeN
+   *      # Vector indices:
+   *      merged[indices[m][i], ...] = data[m][i, ...]
+   *  }</pre>
+   *  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
+   *  <p>
+   *      merged.shape = [max(indices)] + constant
+   *  <p>
+   *  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.
+   *  <p>
+   *  For example:
+   *  <pre>{@code
+   *      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]]
+   *  }</pre>
+   *  This method can be used to merge partitions created by `dynamic_partition`
+   *  as illustrated on the following example:
+   *  <pre>{@code
+   *      # 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.
+   *  }</pre>
+   *  <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>
+   *
+   * @param <T> data type for {@code merged()} output
+   * @param indices
+   * @param data
+   * @return a new instance of ParallelDynamicStitch
    */
-  public <T extends TType> ShapeN<TInt32> shapeN(Iterable<Operand<T>> input) {
-    return ShapeN.create(scope, input);
+  public <T extends TType> ParallelDynamicStitch<T> parallelDynamicStitch(
+      Iterable<Operand<TInt32>> indices, Iterable<Operand<T>> data) {
+    return ParallelDynamicStitch.create(scope, indices, data);
   }
 
   /**
-   * Returns shape of tensors.
+   * A placeholder op for a value that will be fed into the computation.
    *  <p>
-   *  This operation returns N 1-D integer tensors representing shape of `input[i]s`.
+   *  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.
    *
-   * @param <U> data type for {@code output()} output
-   * @param input
-   * @param outType
-   * @return a new instance of ShapeN
+   * @param <T> data type for {@code output()} output
+   * @param dtype The type of elements in the tensor.
+   * @param options carries optional attributes values
+   * @return a new instance of Placeholder
    */
-  public <U extends TNumber, T extends TType> ShapeN<U> shapeN(Iterable<Operand<T>> input,
-      DataType<U> outType) {
-    return ShapeN.create(scope, input, outType);
+  public <T extends TType> Placeholder<T> placeholder(DataType<T> dtype,
+      Placeholder.Options... options) {
+    return Placeholder.create(scope, dtype, options);
   }
 
   /**
-   * Returns the size of a tensor.
-   *  <p>
-   *  This operation returns an integer representing the number of elements in
-   *  `input`.
-   *  <p>
-   *  For example:
-   *  <pre>{@code
-   *  # 't' is [[[1, 1,, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]]
-   *  size(t) ==> 12
-   *  }</pre>
+   * A placeholder op that passes through `input` when its output is not fed.
    *
-   * @param <U> data type for {@code output()} output
-   * @param input
-   * @return a new instance of Size
+   * @param <T> data type for {@code output()} output
+   * @param input The default value to produce when `output` is not fed.
+   * @param shape The (possibly partial) shape of the tensor.
+   * @return a new instance of PlaceholderWithDefault
    */
-  public <T extends TType> Size<TInt32> size(Operand<T> input) {
-    return Size.create(scope, input);
+  public <T extends TType> PlaceholderWithDefault<T> placeholderWithDefault(Operand<T> input,
+      Shape shape) {
+    return PlaceholderWithDefault.create(scope, input, shape);
   }
 
   /**
-   * Returns the size of a tensor.
-   *  <p>
-   *  This operation returns an integer representing the number of elements in
-   *  `input`.
+   * Prints a string scalar.
    *  <p>
-   *  For example:
-   *  <pre>{@code
-   *  # 't' is [[[1, 1,, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]]
-   *  size(t) ==> 12
-   *  }</pre>
+   *  Prints a string scalar to the desired output_stream.
    *
-   * @param <U> data type for {@code output()} output
-   * @param input
-   * @param outType
-   * @return a new instance of Size
+   * @param input The string scalar to print.
+   * @param options carries optional attributes values
+   * @return a new instance of Print
    */
-  public <U extends TNumber, T extends TType> Size<U> size(Operand<T> input, DataType<U> outType) {
-    return Size.create(scope, input, outType);
+  public Print print(Operand<TString> input, Print.Options... options) {
+    return Print.create(scope, input, options);
   }
 
   /**
-   * Parses a text file and creates a batch of examples.
+   * Computes the product of elements across dimensions of a tensor.
+   *  <p>
+   *  Reduces `input` 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 are
+   *  retained with length 1.
    *
-   * @param filename The corpus's text file name.
-   * @param batchSize The size of produced batch.
+   * @param <T> data type for {@code output()} output
+   * @param input The tensor to reduce.
+   * @param axis The dimensions to reduce. Must be in the range
+   *  `[-rank(input), rank(input))`.
    * @param options carries optional attributes values
-   * @return a new instance of Skipgram
+   * @return a new instance of Prod
    */
-  public Skipgram skipgram(String filename, Long batchSize, Skipgram.Options... options) {
-    return Skipgram.create(scope, filename, batchSize, options);
+  public <T extends TType, U extends TNumber> Prod<T> prod(Operand<T> input, Operand<U> axis,
+      Prod.Options... options) {
+    return Prod.create(scope, input, axis, options);
   }
 
   /**
-   * Return a slice from 'input'.
-   *  <p>
-   *  The output tensor is a tensor with dimensions described by 'size'
-   *  whose values are extracted from 'input' starting at the offsets in
-   *  'begin'.
+   * Reshapes a quantized tensor as per the Reshape op.
    *  <p>
-   *  <i>Requirements</i>:
-   *    0 <= begin[i] <= begin[i] + size[i] <= Di  for i in [0, n)
+   *  ```
    *
    * @param <T> data type for {@code output()} output
-   * @param input
-   * @param begin begin[i] specifies the offset into the 'i'th dimension of
-   *  'input' to slice from.
-   * @param size 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]).
-   * @return a new instance of Slice
+   * @param tensor
+   * @param shape Defines the shape of the output tensor.
+   * @param inputMin The minimum value of the input.
+   * @param inputMax The maximum value of the input.
+   * @return a new instance of QuantizedReshape
    */
-  public <T extends TType, U extends TNumber> Slice<T> slice(Operand<T> input, Operand<U> begin,
-      Operand<U> size) {
-    return Slice.create(scope, input, begin, size);
+  public <T extends TType, U extends TNumber> QuantizedReshape<T> quantizedReshape(
+      Operand<T> tensor, Operand<U> shape, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax) {
+    return QuantizedReshape.create(scope, tensor, shape, inputMin, inputMax);
   }
 
   /**
-   * Returns a copy of the input tensor.
+   * Creates a sequence of numbers.
+   *  <p>
+   *  This operation creates a sequence of numbers that begins at `start` and
+   *  extends by increments of `delta` up to but not including `limit`.
+   *  <p>
+   *  For example:
+   *  <pre>{@code
+   *  # 'start' is 3
+   *  # 'limit' is 18
+   *  # 'delta' is 3
+   *  tf.range(start, limit, delta) ==> [3, 6, 9, 12, 15]
+   *  }</pre>
    *
    * @param <T> data type for {@code output()} output
-   * @param input
-   * @return a new instance of Snapshot
+   * @param start 0-D (scalar). First entry in the sequence.
+   * @param limit 0-D (scalar). Upper limit of sequence, exclusive.
+   * @param delta 0-D (scalar). Optional. Default is 1. Number that increments `start`.
+   * @return a new instance of Range
    */
-  public <T extends TType> Snapshot<T> snapshot(Operand<T> input) {
-    return Snapshot.create(scope, input);
+  public <T extends TNumber> Range<T> range(Operand<T> start, Operand<T> limit, Operand<T> delta) {
+    return Range.create(scope, start, limit, delta);
   }
 
   /**
-   * SpaceToBatch for N-D tensors of type T.
+   * Returns the rank of a tensor.
    *  <p>
-   *  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.
+   *  This operation returns an integer representing the rank of `input`.
+   *  <p>
+   *  For example:
+   *  <pre>{@code
+   *  # '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
+   *  }</pre>
+   *  <b>Note</b>: 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."
    *
-   * @param <T> data type for {@code output()} output
-   * @param input N-D with shape `input_shape = [batch] + spatial_shape + remaining_shape`,
-   *  where spatial_shape has `M` dimensions.
-   * @param blockShape 1-D with shape `[M]`, all values must be >= 1.
-   * @param paddings 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`.
+   * @param input
+   * @return a new instance of Rank
+   */
+  public <T extends TType> Rank rank(Operand<T> input) {
+    return Rank.create(scope, input);
+  }
+
+  /**
+   * Reads the value of a variable.
    *  <p>
-   *  This operation is equivalent to the following steps:
+   *  The tensor returned by this operation is immutable.
    *  <p>
-   *  1. Zero-pad the start and end of dimensions `[1, ..., M]` of the
-   *     input according to `paddings` to produce `padded` of shape `padded_shape`.
-   *  <p>
-   *  2. Reshape `padded` to `reshaped_padded` of shape:
-   *  <p>
-   *       [batch] +
-   *       [padded_shape[1] / block_shape[0],
-   *         block_shape[0],
-   *        ...,
-   *        padded_shape[M] / block_shape[M-1],
-   *        block_shape[M-1]] +
-   *       remaining_shape
-   *  <p>
-   *  3. Permute dimensions of `reshaped_padded` to produce
-   *     `permuted_reshaped_padded` of shape:
-   *  <p>
-   *       block_shape +
-   *       [batch] +
-   *       [padded_shape[1] / block_shape[0],
-   *        ...,
-   *        padded_shape[M] / block_shape[M-1]] +
-   *       remaining_shape
-   *  <p>
-   *  4. Reshape `permuted_reshaped_padded` to flatten `block_shape` into the batch
-   *     dimension, producing an output tensor of shape:
-   *  <p>
-   *       [batch * prod(block_shape)] +
-   *       [padded_shape[1] / block_shape[0],
-   *        ...,
-   *        padded_shape[M] / block_shape[M-1]] +
-   *       remaining_shape
-   *  <p>
-   *  Some examples:
-   *  <p>
-   *  (1) For the following input of shape `[1, 2, 2, 1]`, `block_shape = [2, 2]`, and
-   *      `paddings = [[0, 0], [0, 0]]`:
-   *  <pre>{@code
-   *  x = [[[[1], [2]], [[3], [4]]]]
-   *  }</pre>
-   *  The output tensor has shape `[4, 1, 1, 1]` and value:
-   *  <pre>{@code
-   *  [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
-   *  }</pre>
-   *  (2) For the following input of shape `[1, 2, 2, 3]`, `block_shape = [2, 2]`, and
-   *      `paddings = [[0, 0], [0, 0]]`:
-   *  <pre>{@code
-   *  x = [[[[1, 2, 3], [4, 5, 6]],
-   *        [[7, 8, 9], [10, 11, 12]]]]
-   *  }</pre>
-   *  The output tensor has shape `[4, 1, 1, 3]` and value:
-   *  <pre>{@code
-   *  [[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
-   *  }</pre>
-   *  (3) For the following input of shape `[1, 4, 4, 1]`, `block_shape = [2, 2]`, and
-   *      `paddings = [[0, 0], [0, 0]]`:
-   *  <pre>{@code
-   *  x = [[[[1],   [2],  [3],  [4]],
-   *        [[5],   [6],  [7],  [8]],
-   *        [[9],  [10], [11],  [12]],
-   *        [[13], [14], [15],  [16]]]]
-   *  }</pre>
-   *  The output tensor has shape `[4, 2, 2, 1]` and value:
-   *  <pre>{@code
-   *  x = [[[[1], [3]], [[9], [11]]],
-   *       [[[2], [4]], [[10], [12]]],
-   *       [[[5], [7]], [[13], [15]]],
-   *       [[[6], [8]], [[14], [16]]]]
-   *  }</pre>
-   *  (4) For the following input of shape `[2, 2, 4, 1]`, block_shape = `[2, 2]`, and
-   *      paddings = `[[0, 0], [2, 0]]`:
-   *  <pre>{@code
-   *  x = [[[[1],   [2],  [3],  [4]],
-   *        [[5],   [6],  [7],  [8]]],
-   *       [[[9],  [10], [11],  [12]],
-   *        [[13], [14], [15],  [16]]]]
-   *  }</pre>
-   *  The output tensor has shape `[8, 1, 3, 1]` and value:
-   *  <pre>{@code
-   *  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]]]]
-   *  }</pre>
-   *  Among others, this operation is useful for reducing atrous convolution into
-   *  regular convolution.
-   * @return a new instance of SpaceToBatchNd
-   */
-  public <T extends TType, U extends TNumber, V extends TNumber> SpaceToBatchNd<T> spaceToBatchNd(
-      Operand<T> input, Operand<U> blockShape, Operand<V> paddings) {
-    return SpaceToBatchNd.create(scope, input, blockShape, paddings);
-  }
-
-  /**
-   * Splits a tensor into `num_split` tensors along one dimension.
+   *  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.
    *
-   * @param <T> data type for {@code output()} output
-   * @param axis 0-D.  The dimension along which to split.  Must be in the range
-   *  `[-rank(value), rank(value))`.
-   * @param value The tensor to split.
-   * @param numSplit The number of ways to split.  Must evenly divide
-   *  `value.shape[split_dim]`.
-   * @return a new instance of Split
+   * @param <T> data type for {@code value()} output
+   * @param resource handle to the resource in which to store the variable.
+   * @param dtype the dtype of the value.
+   * @return a new instance of ReadVariableOp
    */
-  public <T extends TType> Split<T> split(Operand<TInt32> axis, Operand<T> value, Long numSplit) {
-    return Split.create(scope, axis, value, numSplit);
+  public <T extends TType> ReadVariableOp<T> readVariableOp(Operand<?> resource,
+      DataType<T> dtype) {
+    return ReadVariableOp.create(scope, resource, dtype);
   }
 
   /**
-   * Splits a tensor into `num_split` tensors along one dimension.
+   * Computes the "logical and" of elements across dimensions of a tensor.
+   *  <p>
+   *  Reduces `input` 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 are
+   *  retained with length 1.
    *
-   * @param <T> data type for {@code output()} output
-   * @param value The tensor to split.
-   * @param sizeSplits 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.
-   * @param axis 0-D.  The dimension along which to split.  Must be in the range
-   *  `[-rank(value), rank(value))`.
-   * @param numSplit
-   * @return a new instance of SplitV
+   * @param input The tensor to reduce.
+   * @param axis The dimensions to reduce. Must be in the range
+   *  `[-rank(input), rank(input))`.
+   * @param options carries optional attributes values
+   * @return a new instance of ReduceAll
    */
-  public <T extends TType, U extends TNumber> SplitV<T> splitV(Operand<T> value,
-      Operand<U> sizeSplits, Operand<TInt32> axis, Long numSplit) {
-    return SplitV.create(scope, value, sizeSplits, axis, numSplit);
+  public <T extends TNumber> ReduceAll reduceAll(Operand<TBool> input, Operand<T> axis,
+      ReduceAll.Options... options) {
+    return ReduceAll.create(scope, input, axis, options);
   }
 
   /**
-   * Removes dimensions of size 1 from the shape of a tensor.
-   *  <p>
-   *  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
-   *  `axis`.
+   * Computes the "logical or" of elements across dimensions of a tensor.
    *  <p>
-   *  For example:
-   *  <pre>{@code
-   *  # 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
-   *  shape(squeeze(t)) ==> [2, 3]
-   *  }</pre>
-   *  Or, to remove specific size 1 dimensions:
-   *  <pre>{@code
-   *  # 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
-   *  shape(squeeze(t, [2, 4])) ==> [1, 2, 3, 1]
-   *  }</pre>
+   *  Reduces `input` 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 are
+   *  retained with length 1.
    *
-   * @param <T> data type for {@code output()} output
-   * @param input The `input` to squeeze.
+   * @param input The tensor to reduce.
+   * @param axis The dimensions to reduce. Must be in the range
+   *  `[-rank(input), rank(input))`.
    * @param options carries optional attributes values
-   * @return a new instance of Squeeze
+   * @return a new instance of ReduceAny
    */
-  public <T extends TType> Squeeze<T> squeeze(Operand<T> input, Squeeze.Options... options) {
-    return Squeeze.create(scope, input, options);
+  public <T extends TNumber> ReduceAny reduceAny(Operand<TBool> input, Operand<T> axis,
+      ReduceAny.Options... options) {
+    return ReduceAny.create(scope, input, axis, options);
   }
 
   /**
-   * Packs a list of `N` rank-`R` tensors into one rank-`(R+1)` tensor.
-   *  <p>
-   *  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)`;
-   *  <p>
-   *  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.
+   * Computes the maximum of elements across dimensions of a tensor.
    *  <p>
-   *  For example:
-   *  <pre>{@code
-   *  # '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]]
-   *  }</pre>
-   *  This is the opposite of `unpack`.
+   *  Reduces `input` 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 are
+   *  retained with length 1.
    *
    * @param <T> data type for {@code output()} output
-   * @param values Must be of same shape and type.
+   * @param input The tensor to reduce.
+   * @param axis The dimensions to reduce. Must be in the range
+   *  `[-rank(input), rank(input))`.
    * @param options carries optional attributes values
-   * @return a new instance of Stack
+   * @return a new instance of ReduceMax
    */
-  public <T extends TType> Stack<T> stack(Iterable<Operand<T>> values, Stack.Options... options) {
-    return Stack.create(scope, values, options);
+  public <T extends TType, U extends TNumber> ReduceMax<T> reduceMax(Operand<T> input,
+      Operand<U> axis, ReduceMax.Options... options) {
+    return ReduceMax.create(scope, input, axis, options);
   }
 
   /**
-   * Stage values similar to a lightweight Enqueue.
+   * Computes the minimum of elements across dimensions of a tensor.
    *  <p>
-   *  The basic functionality of this Op is similar to a queue with many
-   *  fewer capabilities and options.  This Op is optimized for performance.
+   *  Reduces `input` 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 are
+   *  retained with length 1.
    *
-   * @param values a list of tensors
-   *  dtypes A list of data types that inserted values should adhere to.
+   * @param <T> data type for {@code output()} output
+   * @param input The tensor to reduce.
+   * @param axis The dimensions to reduce. Must be in the range
+   *  `[-rank(input), rank(input))`.
    * @param options carries optional attributes values
-   * @return a new instance of Stage
+   * @return a new instance of ReduceMin
    */
-  public Stage stage(Iterable<Operand<?>> values, Stage.Options... options) {
-    return Stage.create(scope, values, options);
+  public <T extends TType, U extends TNumber> ReduceMin<T> reduceMin(Operand<T> input,
+      Operand<U> axis, ReduceMin.Options... options) {
+    return ReduceMin.create(scope, input, axis, options);
   }
 
   /**
-   * Op removes all elements in the underlying container.
+   * Computes the product of elements across dimensions of a tensor.
+   *  <p>
+   *  Reduces `input` 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 are
+   *  retained with length 1.
    *
-   * @param dtypes
+   * @param <T> data type for {@code output()} output
+   * @param input The tensor to reduce.
+   * @param axis The dimensions to reduce. Must be in the range
+   *  `[-rank(input), rank(input))`.
    * @param options carries optional attributes values
-   * @return a new instance of StageClear
+   * @return a new instance of ReduceProd
    */
-  public StageClear stageClear(List<DataType<?>> dtypes, StageClear.Options... options) {
-    return StageClear.create(scope, dtypes, options);
+  public <T extends TType, U extends TNumber> ReduceProd<T> reduceProd(Operand<T> input,
+      Operand<U> axis, ReduceProd.Options... options) {
+    return ReduceProd.create(scope, input, axis, options);
   }
 
   /**
-   * Op peeks at the values at the specified index.  If the
+   * Computes the sum of elements across dimensions of a tensor.
    *  <p>
-   *  underlying container does not contain sufficient elements
-   *  this op will block until it does.   This Op is optimized for
-   *  performance.
+   *  Reduces `input` 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 are
+   *  retained with length 1.
    *
-   * @param index
-   * @param dtypes
+   * @param <T> data type for {@code output()} output
+   * @param input The tensor to reduce.
+   * @param axis The dimensions to reduce. Must be in the range
+   *  `[-rank(input), rank(input))`.
    * @param options carries optional attributes values
-   * @return a new instance of StagePeek
+   * @return a new instance of ReduceSum
    */
-  public StagePeek stagePeek(Operand<TInt32> index, List<DataType<?>> dtypes,
-      StagePeek.Options... options) {
-    return StagePeek.create(scope, index, dtypes, options);
+  public <T extends TType, U extends TNumber> ReduceSum<T> reduceSum(Operand<T> input,
+      Operand<U> axis, ReduceSum.Options... options) {
+    return ReduceSum.create(scope, input, axis, options);
   }
 
   /**
-   * Op returns the number of elements in the underlying container.
+   * Makes its input available to the next iteration.
    *
-   * @param dtypes
-   * @param options carries optional attributes values
-   * @return a new instance of StageSize
+   * @param <T> data type for {@code output()} output
+   * @param data The tensor to be made available to the next iteration.
+   * @return a new instance of RefNextIteration
    */
-  public StageSize stageSize(List<DataType<?>> dtypes, StageSize.Options... options) {
-    return StageSize.create(scope, dtypes, options);
+  public <T extends TType> RefNextIteration<T> refNextIteration(Operand<T> data) {
+    return RefNextIteration.create(scope, data);
   }
 
   /**
-   * Stops gradient computation.
-   *  <p>
-   *  When executed in a graph, this op outputs its input tensor as-is.
-   *  <p>
-   *  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.
-   *  <p>
-   *  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:
-   *  <ul>
-   *  <li>
-   *  The <i>EM</i> algorithm where the <i>M-step</i> should not involve backpropagation
-   *     through the output of the <i>E-step</i>.
-   *  </li>
-   *  <li>
-   *  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.
-   *  </li>
-   *  <li>
-   *  Adversarial training, where no backprop should happen through the adversarial
-   *     example generation process.
+   * Forwards the `index`th element of `inputs` to `output`.
    *
    * @param <T> data type for {@code output()} output
-   * @param input
-   * @return a new instance of StopGradient
+   * @param index A scalar that determines the input that gets selected.
+   * @param inputs A list of ref tensors, one of which will be forwarded to `output`.
+   * @return a new instance of RefSelect
    */
-  public <T extends TType> StopGradient<T> stopGradient(Operand<T> input) {
-    return StopGradient.create(scope, input);
+  public <T extends TType> RefSelect<T> refSelect(Operand<TInt32> index,
+      Iterable<Operand<T>> inputs) {
+    return RefSelect.create(scope, index, inputs);
   }
 
   /**
-   * Return a strided slice from `input`.
-   *  <p>
-   *  Note, most python users will want to use the Python `Tensor.__getitem__`
-   *  or `Variable.__getitem__` rather than this op directly.
-   *  <p>
-   *  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:
-   *  <p>
-   *  - 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.
-   *  <p>
-   *  - 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.
-   *  <p>
-   *  - 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]`.
-   *  <p>
-   *  - 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`.
-   *  <p>
-   *  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
-   *  <pre>{@code
-   *  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
-   *  }</pre>
-   *  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.
-   *  <p>
-   *  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`.
-   *  <p>
-   *  2. `2:4` is contributes 2, 4, 1 to begin, end, and stride. All masks have
-   *  zero bits contributed.
-   *  <p>
-   *  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.
-   *  <p>
-   *  4. `...` grab the full ranges from as many dimensions as needed to
-   *  fully specify a slice for every dimension of the input shape.
-   *  <p>
-   *  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).
+   * Forwards the ref tensor `data` to the output port determined by `pred`.
    *  <p>
-   *  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.
+   *  If `pred` is true, the `data` input is forwarded to `output_true`. Otherwise,
+   *  the data goes to `output_false`.
    *  <p>
-   *  <i>Requirements</i>:
-   *    `0 != strides[i] for i in [0, m)`
-   *    `ellipsis_mask must be a power of two (only one ellipsis)`
+   *  See also `Switch` and `Merge`.
    *
-   * @param <T> data type for {@code output()} output
-   * @param input
-   * @param begin `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`.
-   * @param end `end[i]` is like `begin` with the exception that `end_mask` is
-   *  used to determine full ranges.
-   * @param strides `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`
-   * @param options carries optional attributes values
-   * @return a new instance of StridedSlice
+   * @param <T> data type for {@code outputFalse()} output
+   * @param data The ref tensor to be forwarded to the appropriate output.
+   * @param pred A scalar that specifies which output port will receive data.
+   * @return a new instance of RefSwitch
    */
-  public <T extends TType, U extends TNumber> StridedSlice<T> stridedSlice(Operand<T> input,
-      Operand<U> begin, Operand<U> end, Operand<U> strides, StridedSlice.Options... options) {
-    return StridedSlice.create(scope, input, begin, end, strides, options);
+  public <T extends TType> RefSwitch<T> refSwitch(Operand<T> data, Operand<TBool> pred) {
+    return RefSwitch.create(scope, data, pred);
   }
 
   /**
-   * Assign `value` to the sliced l-value reference of `ref`.
-   *  <p>
-   *  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`.
+   * Execute a sub graph on a remote processor.
    *  <p>
-   *  NOTE this op currently does not support broadcasting and so `value`'s
-   *  shape must be exactly the shape produced by the slice of `ref`.
+   *  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.
    *
-   * @param <T> data type for {@code outputRef()} output
-   * @param ref
-   * @param begin
-   * @param end
-   * @param strides
-   * @param value
-   * @param options carries optional attributes values
-   * @return a new instance of StridedSliceAssign
+   * @param inputs Arbitrary number of tensors with arbitrary data types
+   * @param Toutputs
+   * @param serializedRemoteFusedGraphExecuteInfo Serialized protocol buffer
+   *  of RemoteFusedGraphExecuteInfo which contains graph specifications.
+   * @return a new instance of RemoteFusedGraphExecute
    */
-  public <T extends TType, U extends TNumber> StridedSliceAssign<T> stridedSliceAssign(
-      Operand<T> ref, Operand<U> begin, Operand<U> end, Operand<U> strides, Operand<T> value,
-      StridedSliceAssign.Options... options) {
-    return StridedSliceAssign.create(scope, ref, begin, end, strides, value, options);
+  public RemoteFusedGraphExecute remoteFusedGraphExecute(Iterable<Operand<?>> inputs,
+      List<DataType<?>> Toutputs, String serializedRemoteFusedGraphExecuteInfo) {
+    return RemoteFusedGraphExecute.create(scope, inputs, Toutputs, serializedRemoteFusedGraphExecuteInfo);
   }
 
   /**
-   * Returns the gradient of `StridedSlice`.
+   * Reshapes a tensor.
    *  <p>
-   *  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.
+   *  Given `tensor`, this operation returns a tensor that has the same values
+   *  as `tensor` with shape `shape`.
    *  <p>
-   *  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`.
-   *
-   * @param <U> data type for {@code output()} output
-   * @param shape
-   * @param begin
-   * @param end
-   * @param strides
-   * @param dy
-   * @param options carries optional attributes values
-   * @return a new instance of StridedSliceGrad
-   */
-  public <U extends TType, T extends TNumber> StridedSliceGrad<U> stridedSliceGrad(Operand<T> shape,
-      Operand<T> begin, Operand<T> end, Operand<T> strides, Operand<U> dy,
-      StridedSliceGrad.Options... options) {
-    return StridedSliceGrad.create(scope, shape, begin, end, strides, dy, options);
-  }
-
-  /**
-   * Computes the sum of elements across dimensions of a tensor.
+   *  If one component of 1-D tensor `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` may be
+   *  unknown.
    *  <p>
-   *  Reduces `input` 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 are
-   *  retained with length 1.
-   *
-   * @param <T> data type for {@code output()} output
-   * @param input The tensor to reduce.
-   * @param axis The dimensions to reduce. Must be in the range
-   *  `[-rank(input), rank(input))`.
-   * @param options carries optional attributes values
-   * @return a new instance of Sum
-   */
-  public <T extends TType, U extends TNumber> Sum<T> sum(Operand<T> input, Operand<U> axis,
-      Sum.Options... options) {
-    return Sum.create(scope, input, axis, options);
-  }
-
-  /**
-   * Forwards `data` to the output port determined by `pred`.
+   *  The `shape` must be 1-D and 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`.
    *  <p>
-   *  If `pred` is true, the `data` input is forwarded to `output_true`. Otherwise,
-   *  the data goes to `output_false`.
+   *  It is an error if `shape` is not 1-D.
    *  <p>
-   *  See also `RefSwitch` and `Merge`.
+   *  For example:
+   *  <pre>{@code
+   *  # 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]]
    *
-   * @param <T> data type for {@code outputFalse()} output
-   * @param data The tensor to be forwarded to the appropriate output.
-   * @param pred A scalar that specifies which output port will receive data.
-   * @return a new instance of SwitchCond
+   *  # 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
+   *  }</pre>
+   *
+   * @param <T> data type for {@code output()} output
+   * @param tensor
+   * @param shape Defines the shape of the output tensor.
+   * @return a new instance of Reshape
    */
-  public <T extends TType> SwitchCond<T> switchCond(Operand<T> data, Operand<TBool> pred) {
-    return SwitchCond.create(scope, data, pred);
+  public <T extends TType, U extends TNumber> Reshape<T> reshape(Operand<T> tensor,
+      Operand<U> shape) {
+    return Reshape.create(scope, tensor, shape);
   }
 
   /**
-   * Returns a tensor that may be mutated, but only persists within a single step.
-   *  <p>
-   *  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.
-   *  <p>
-   *  It is the caller's responsibility to ensure that 'ref' is eventually passed to a
-   *  matching 'DestroyTemporaryVariable' op after all other uses have completed.
-   *  <p>
-   *  Outputs a ref to the tensor state so it may be read or modified.
-   *  <p>
-   *    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)
+   * Increments variable pointed to by 'resource' until it reaches 'limit'.
    *
-   * @param <T> data type for {@code ref()} output
-   * @param shape The shape of the variable tensor.
-   * @param dtype The type of elements in the variable tensor.
-   * @param options carries optional attributes values
-   * @return a new instance of TemporaryVariable
+   * @param <T> data type for {@code output()} output
+   * @param resource Should be from a scalar `Variable` node.
+   * @param limit If incrementing ref would bring it above limit, instead generates an
+   *  'OutOfRange' error.
+   * @param T
+   * @return a new instance of ResourceCountUpTo
    */
-  public <T extends TType> TemporaryVariable<T> temporaryVariable(Shape shape, DataType<T> dtype,
-      TemporaryVariable.Options... options) {
-    return TemporaryVariable.create(scope, shape, dtype, options);
+  public <T extends TNumber> ResourceCountUpTo<T> resourceCountUpTo(Operand<?> resource, Long limit,
+      DataType<T> T) {
+    return ResourceCountUpTo.create(scope, resource, limit, T);
   }
 
   /**
-   * An array of Tensors of given size.
+   * Gather slices from the variable pointed to by `resource` according to `indices`.
    *  <p>
-   *  Write data via Write and read via Read or Pack.
+   *  `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:
+   *  <pre>{@code
+   *      # Scalar indices
+   *      output[:, ..., :] = params[indices, :, ... :]
    *
-   * @param size The size of the array.
-   * @param dtype The type of the elements on the tensor_array.
+   *      # Vector indices
+   *      output[i, :, ..., :] = params[indices[i], :, ... :]
+   *
+   *      # Higher rank indices
+   *      output[i, ..., j, :, ... :] = params[indices[i, ..., j], :, ..., :]
+   *  }</pre>
+   *
+   * @param <U> data type for {@code output()} output
+   * @param resource
+   * @param indices
+   * @param dtype
    * @param options carries optional attributes values
-   * @return a new instance of TensorArray
+   * @return a new instance of ResourceGather
    */
-  public <T extends TType> TensorArray tensorArray(Operand<TInt32> size, DataType<T> dtype,
-      TensorArray.Options... options) {
-    return TensorArray.create(scope, size, dtype, options);
+  public <U extends TType, T extends TNumber> ResourceGather<U> resourceGather(Operand<?> resource,
+      Operand<T> indices, DataType<U> dtype, ResourceGather.Options... options) {
+    return ResourceGather.create(scope, resource, indices, dtype, options);
   }
 
   /**
-   * Delete the TensorArray from its resource container.
-   *  <p>
-   *  This enables the user to close and release the resource in the middle
-   *  of a step/run.
    *
-   * @param handle The handle to a TensorArray (output of TensorArray or TensorArrayGrad).
-   * @return a new instance of TensorArrayClose
+   * @param <U> data type for {@code output()} output
+   * @param resource
+   * @param indices
+   * @param dtype
+   * @return a new instance of ResourceGatherNd
    */
-  public TensorArrayClose tensorArrayClose(Operand<?> handle) {
-    return TensorArrayClose.create(scope, handle);
+  public <U extends TType, T extends TNumber> ResourceGatherNd<U> resourceGatherNd(
+      Operand<?> resource, Operand<T> indices, DataType<U> dtype) {
+    return ResourceGatherNd.create(scope, resource, indices, dtype);
   }
 
   /**
-   * Concat the elements from the TensorArray into value `value`.
+   * Adds sparse updates to the variable referenced by `resource`.
    *  <p>
-   *  Takes `T` elements of shapes
+   *  This operation computes
    *  <p>
-   *    <pre>{@code
-   *    (n0 x d0 x d1 x ...), (n1 x d0 x d1 x ...), ..., (n(T-1) x d0 x d1 x ...)
-   *    }</pre>
-   *  and concatenates them into a Tensor of shape:
+   *      # Scalar indices
+   *      ref[indices, ...] += updates[...]
    *  <p>
-   *    <pre>{@code
-   *  (n0 + n1 + ... + n(T-1) x d0 x d1 x ...)}</pre>
-   *  All elements must have the same shape (excepting the first dimension).
+   *      # Vector indices (for each i)
+   *      ref[indices[i], ...] += updates[i, ...]
+   *  <p>
+   *      # High rank indices (for each i, ..., j)
+   *      ref[indices[i, ..., j], ...] += updates[i, ..., j, ...]
+   *  <p>
+   *  Duplicate entries are handled correctly: if multiple `indices` reference
+   *  the same location, their contributions add.
+   *  <p>
+   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+   *  <p>
+   *  <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>
    *
-   * @param <T> data type for {@code value()} output
-   * @param handle The handle to a TensorArray.
-   * @param flowIn A float scalar that enforces proper chaining of operations.
-   * @param dtype The type of the elem that is returned.
-   * @param options carries optional attributes values
-   * @return a new instance of TensorArrayConcat
+   * @param resource Should be from a `Variable` node.
+   * @param indices A tensor of indices into the first dimension of `ref`.
+   * @param updates A tensor of updated values to add to `ref`.
+   * @return a new instance of ResourceScatterAdd
    */
-  public <T extends TType> TensorArrayConcat<T> tensorArrayConcat(Operand<?> handle,
-      Operand<TFloat32> flowIn, DataType<T> dtype, TensorArrayConcat.Options... options) {
-    return TensorArrayConcat.create(scope, handle, flowIn, dtype, options);
+  public <T extends TNumber, U extends TType> ResourceScatterAdd resourceScatterAdd(
+      Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+    return ResourceScatterAdd.create(scope, resource, indices, updates);
   }
 
   /**
-   * Gather specific elements from the TensorArray into output `value`.
+   * Divides sparse updates into the variable referenced by `resource`.
    *  <p>
-   *  All elements selected by `indices` must have the same shape.
+   *  This operation computes
+   *  <p>
+   *      # Scalar indices
+   *      ref[indices, ...] /= updates[...]
+   *  <p>
+   *      # Vector indices (for each i)
+   *      ref[indices[i], ...] /= updates[i, ...]
+   *  <p>
+   *      # High rank indices (for each i, ..., j)
+   *      ref[indices[i, ..., j], ...] /= updates[i, ..., j, ...]
+   *  <p>
+   *  Duplicate entries are handled correctly: if multiple `indices` reference
+   *  the same location, their contributions multiply.
+   *  <p>
+   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+   *  <p>
+   *  <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>
    *
-   * @param <T> data type for {@code value()} output
-   * @param handle The handle to a TensorArray.
-   * @param indices The locations in the TensorArray from which to read tensor elements.
-   * @param flowIn A float scalar that enforces proper chaining of operations.
-   * @param dtype The type of the elem that is returned.
-   * @param options carries optional attributes values
-   * @return a new instance of TensorArrayGather
+   * @param resource Should be from a `Variable` node.
+   * @param indices A tensor of indices into the first dimension of `ref`.
+   * @param updates A tensor of updated values to add to `ref`.
+   * @return a new instance of ResourceScatterDiv
    */
-  public <T extends TType> TensorArrayGather<T> tensorArrayGather(Operand<?> handle,
-      Operand<TInt32> indices, Operand<TFloat32> flowIn, DataType<T> dtype,
-      TensorArrayGather.Options... options) {
-    return TensorArrayGather.create(scope, handle, indices, flowIn, dtype, options);
+  public <T extends TNumber, U extends TType> ResourceScatterDiv resourceScatterDiv(
+      Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+    return ResourceScatterDiv.create(scope, resource, indices, updates);
   }
 
   /**
-   * Creates a TensorArray for storing the gradients of values in the given handle.
+   * Reduces sparse updates into the variable referenced by `resource` using the `max` operation.
    *  <p>
-   *  If the given TensorArray gradient already exists, returns a reference to it.
+   *  This operation computes
    *  <p>
-   *  Locks the size of the original TensorArray by disabling its dynamic size flag.
+   *      # Scalar indices
+   *      ref[indices, ...] = max(ref[indices, ...], updates[...])
    *  <p>
-   * *A note about the input flow_in:**
+   *      # Vector indices (for each i)
+   *      ref[indices[i], ...] = max(ref[indices[i], ...], updates[i, ...])
    *  <p>
-   *  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.
+   *      # High rank indices (for each i, ..., j)
+   *      ref[indices[i, ..., j], ...] = max(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
    *  <p>
-   *  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.
-   *  <p>
-   * *A note about the source attribute:**
-   *  <p>
-   *  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.
+   *  Duplicate entries are handled correctly: if multiple `indices` reference
+   *  the same location, their contributions are combined.
    *  <p>
-   *  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`).
+   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
    *  <p>
-   *  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.
+   *  <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>
    *
-   * @param handle The handle to the forward TensorArray.
-   * @param flowIn A float scalar that enforces proper chaining of operations.
-   * @param source The gradient source string, used to decide which gradient TensorArray
-   *  to return.
-   * @return a new instance of TensorArrayGrad
+   * @param resource Should be from a `Variable` node.
+   * @param indices A tensor of indices into the first dimension of `ref`.
+   * @param updates A tensor of updated values to add to `ref`.
+   * @return a new instance of ResourceScatterMax
    */
-  public TensorArrayGrad tensorArrayGrad(Operand<?> handle, Operand<TFloat32> flowIn,
-      String source) {
-    return TensorArrayGrad.create(scope, handle, flowIn, source);
+  public <T extends TNumber, U extends TType> ResourceScatterMax resourceScatterMax(
+      Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+    return ResourceScatterMax.create(scope, resource, indices, updates);
   }
 
   /**
-   * Creates a TensorArray for storing multiple gradients of values in the given handle.
+   * Reduces sparse updates into the variable referenced by `resource` using the `min` operation.
    *  <p>
-   *  Similar to TensorArrayGradV3. However it creates an accumulator with an
-   *  expanded shape compared to the input TensorArray whose gradient is being
-   *  computed. This enables multiple gradients for the same TensorArray to be
-   *  calculated using the same accumulator.
-   *
-   * @param handle The handle to the forward TensorArray.
-   * @param flowIn A float scalar that enforces proper chaining of operations.
-   * @param shapeToPrepend An int32 vector representing a shape. Elements in the gradient accumulator will
-   *  have shape which is this shape_to_prepend value concatenated with shape of the
-   *  elements in the TensorArray corresponding to the input handle.
-   * @param source The gradient source string, used to decide which gradient TensorArray
-   *  to return.
-   * @return a new instance of TensorArrayGradWithShape
-   */
-  public TensorArrayGradWithShape tensorArrayGradWithShape(Operand<?> handle,
-      Operand<TFloat32> flowIn, Operand<TInt32> shapeToPrepend, String source) {
-    return TensorArrayGradWithShape.create(scope, handle, flowIn, shapeToPrepend, source);
-  }
-
-  /**
+   *  This operation computes
+   *  <p>
+   *      # Scalar indices
+   *      ref[indices, ...] = min(ref[indices, ...], updates[...])
+   *  <p>
+   *      # Vector indices (for each i)
+   *      ref[indices[i], ...] = min(ref[indices[i], ...], updates[i, ...])
+   *  <p>
+   *      # High rank indices (for each i, ..., j)
+   *      ref[indices[i, ..., j], ...] = min(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
+   *  <p>
+   *  Duplicate entries are handled correctly: if multiple `indices` reference
+   *  the same location, their contributions are combined.
+   *  <p>
+   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+   *  <p>
+   *  <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>
    *
-   * @param <T> data type for {@code value()} output
-   * @param handle
-   * @param flowIn
-   * @param dtype
-   * @param options carries optional attributes values
-   * @return a new instance of TensorArrayPack
+   * @param resource Should be from a `Variable` node.
+   * @param indices A tensor of indices into the first dimension of `ref`.
+   * @param updates A tensor of updated values to add to `ref`.
+   * @return a new instance of ResourceScatterMin
    */
-  public <T extends TType> TensorArrayPack<T> tensorArrayPack(Operand<TString> handle,
-      Operand<TFloat32> flowIn, DataType<T> dtype, TensorArrayPack.Options... options) {
-    return TensorArrayPack.create(scope, handle, flowIn, dtype, options);
+  public <T extends TNumber, U extends TType> ResourceScatterMin resourceScatterMin(
+      Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+    return ResourceScatterMin.create(scope, resource, indices, updates);
   }
 
   /**
-   * Read an element from the TensorArray into output `value`.
+   * Multiplies sparse updates into the variable referenced by `resource`.
+   *  <p>
+   *  This operation computes
+   *  <p>
+   *      # Scalar indices
+   *      ref[indices, ...] *= updates[...]
+   *  <p>
+   *      # Vector indices (for each i)
+   *      ref[indices[i], ...] *= updates[i, ...]
+   *  <p>
+   *      # High rank indices (for each i, ..., j)
+   *      ref[indices[i, ..., j], ...] *= updates[i, ..., j, ...]
+   *  <p>
+   *  Duplicate entries are handled correctly: if multiple `indices` reference
+   *  the same location, their contributions multiply.
+   *  <p>
+   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+   *  <p>
+   *  <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>
    *
-   * @param <T> data type for {@code value()} output
-   * @param handle The handle to a TensorArray.
-   * @param index
-   * @param flowIn A float scalar that enforces proper chaining of operations.
-   * @param dtype The type of the elem that is returned.
-   * @return a new instance of TensorArrayRead
+   * @param resource Should be from a `Variable` node.
+   * @param indices A tensor of indices into the first dimension of `ref`.
+   * @param updates A tensor of updated values to add to `ref`.
+   * @return a new instance of ResourceScatterMul
    */
-  public <T extends TType> TensorArrayRead<T> tensorArrayRead(Operand<?> handle,
-      Operand<TInt32> index, Operand<TFloat32> flowIn, DataType<T> dtype) {
-    return TensorArrayRead.create(scope, handle, index, flowIn, dtype);
+  public <T extends TNumber, U extends TType> ResourceScatterMul resourceScatterMul(
+      Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+    return ResourceScatterMul.create(scope, resource, indices, updates);
   }
 
   /**
-   * Scatter the data from the input value into specific TensorArray elements.
+   * Applies sparse addition to individual values or slices in a Variable.
    *  <p>
-   *  `indices` must be a vector, its length must match the first dim of `value`.
+   *  `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
+   *  <p>
+   *  `indices` must be integer tensor, containing indices into `ref`.
+   *  It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
+   *  <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`.
+   *  <p>
+   *  `updates` is `Tensor` of rank `Q-1+P-K` with shape:
+   *  <pre>{@code
+   *  [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]]
+   *  }</pre>
+   *  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:
+   *  <pre>{@code
+   *  ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8], use_resource=True)
+   *  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)
+   *  }</pre>
+   *  The resulting update to ref would look like this:
+   *  <p>
+   *      [1, 13, 3, 14, 14, 6, 7, 20]
+   *  <p>
+   *  See `tf.scatter_nd` for more details about how to make updates to
+   *  slices.
    *
-   * @param handle The handle to a TensorArray.
-   * @param indices The locations at which to write the tensor elements.
-   * @param value The concatenated tensor to write to the TensorArray.
-   * @param flowIn A float scalar that enforces proper chaining of operations.
-   * @return a new instance of TensorArrayScatter
+   * @param ref A resource handle. Must be from a VarHandleOp.
+   * @param indices A Tensor. Must be one of the following types: int32, int64.
+   *  A tensor of indices into ref.
+   * @param updates A Tensor. Must have the same type as ref. A tensor of
+   *  values to add to ref.
+   * @param options carries optional attributes values
+   * @return a new instance of ResourceScatterNdAdd
    */
-  public <T extends TType> TensorArrayScatter tensorArrayScatter(Operand<?> handle,
-      Operand<TInt32> indices, Operand<T> value, Operand<TFloat32> flowIn) {
-    return TensorArrayScatter.create(scope, handle, indices, value, flowIn);
+  public <T extends TNumber, U extends TType> ResourceScatterNdAdd resourceScatterNdAdd(
+      Operand<?> ref, Operand<T> indices, Operand<U> updates,
+      ResourceScatterNdAdd.Options... options) {
+    return ResourceScatterNdAdd.create(scope, ref, indices, updates, options);
   }
 
   /**
-   * Get the current size of the TensorArray.
+   * Applies sparse subtraction to individual values or slices in a Variable.
+   *  <p>
+   *  `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
+   *  <p>
+   *  `indices` must be integer tensor, containing indices into `ref`.
+   *  It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
+   *  <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`.
+   *  <p>
+   *  `updates` is `Tensor` of rank `Q-1+P-K` with shape:
+   *  <pre>{@code
+   *  [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]]
+   *  }</pre>
+   *  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:
+   *  <pre>{@code
+   *  ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8], use_resource=True)
+   *  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)
+   *  }</pre>
+   *  The resulting update to ref would look like this:
+   *  <p>
+   *      [1, -9, 3, -6, -4, 6, 7, -4]
+   *  <p>
+   *  See `tf.scatter_nd` for more details about how to make updates to
+   *  slices.
    *
-   * @param handle The handle to a TensorArray (output of TensorArray or TensorArrayGrad).
-   * @param flowIn A float scalar that enforces proper chaining of operations.
-   * @return a new instance of TensorArraySize
+   * @param ref A resource handle. Must be from a VarHandleOp.
+   * @param indices A Tensor. Must be one of the following types: int32, int64.
+   *  A tensor of indices into ref.
+   * @param updates A Tensor. Must have the same type as ref. A tensor of
+   *  values to add to ref.
+   * @param options carries optional attributes values
+   * @return a new instance of ResourceScatterNdSub
    */
-  public TensorArraySize tensorArraySize(Operand<?> handle, Operand<TFloat32> flowIn) {
-    return TensorArraySize.create(scope, handle, flowIn);
+  public <T extends TNumber, U extends TType> ResourceScatterNdSub resourceScatterNdSub(
+      Operand<?> ref, Operand<T> indices, Operand<U> updates,
+      ResourceScatterNdSub.Options... options) {
+    return ResourceScatterNdSub.create(scope, ref, indices, updates, options);
   }
 
   /**
-   * Split the data from the input value into TensorArray elements.
-   *  <p>
-   *  Assuming that `lengths` takes on values
-   *  <p>
-   *    <pre>{@code
-   *  (n0, n1, ..., n(T-1))}</pre>
-   *  and that `value` has shape
+   * Applies sparse `updates` to individual values or slices within a given
    *  <p>
-   *    <pre>{@code
-   *  (n0 + n1 + ... + n(T-1) x d0 x d1 x ...)}</pre>
-   *  ,
+   *  variable according to `indices`.
    *  <p>
-   *  this splits values into a TensorArray with T tensors.
+   *  `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
    *  <p>
-   *  TensorArray index t will be the subtensor of values with starting position
+   *  `indices` must be integer tensor, containing indices into `ref`.
+   *  It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
    *  <p>
-   *    <pre>{@code
-   *  (n0 + n1 + ... + n(t-1), 0, 0, ...)}</pre>
-   *  and having size
+   *  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`.
    *  <p>
-   *    <pre>{@code
-   *  nt x d0 x d1 x ...}</pre>
-   *
-   * @param handle The handle to a TensorArray.
-   * @param value The concatenated tensor to write to the TensorArray.
-   * @param lengths The vector of lengths, how to split the rows of value into the
-   *  TensorArray.
-   * @param flowIn A float scalar that enforces proper chaining of operations.
-   * @return a new instance of TensorArraySplit
-   */
-  public <T extends TType> TensorArraySplit tensorArraySplit(Operand<?> handle, Operand<T> value,
-      Operand<TInt64> lengths, Operand<TFloat32> flowIn) {
-    return TensorArraySplit.create(scope, handle, value, lengths, flowIn);
-  }
-
-  /**
-   *
-   * @param handle
-   * @param value
-   * @param flowIn
-   * @return a new instance of TensorArrayUnpack
-   */
-  public <T extends TType> TensorArrayUnpack tensorArrayUnpack(Operand<TString> handle,
-      Operand<T> value, Operand<TFloat32> flowIn) {
-    return TensorArrayUnpack.create(scope, handle, value, flowIn);
-  }
-
-  /**
-   * Push an element onto the tensor_array.
+   *  `updates` is `Tensor` of rank `Q-1+P-K` with shape:
+   *  <pre>{@code
+   *  [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
+   *  }</pre>
+   *  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:
+   *  <pre>{@code
+   *      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)
+   *  }</pre>
+   *  The resulting update to ref would look like this:
+   *  <p>
+   *      [1, 11, 3, 10, 9, 6, 7, 12]
+   *  <p>
+   *  See `tf.scatter_nd` for more details about how to make updates to
+   *  slices.
    *
-   * @param handle The handle to a TensorArray.
-   * @param index The position to write to inside the TensorArray.
-   * @param value The tensor to write to the TensorArray.
-   * @param flowIn A float scalar that enforces proper chaining of operations.
-   * @return a new instance of TensorArrayWrite
+   * @param ref A resource handle. Must be from a VarHandleOp.
+   * @param indices A Tensor. Must be one of the following types: int32, int64.
+   *  A tensor of indices into ref.
+   * @param updates A Tensor. Must have the same type as ref. A tensor of updated
+   *  values to add to ref.
+   * @param options carries optional attributes values
+   * @return a new instance of ResourceScatterNdUpdate
    */
-  public <T extends TType> TensorArrayWrite tensorArrayWrite(Operand<?> handle,
-      Operand<TInt32> index, Operand<T> value, Operand<TFloat32> flowIn) {
-    return TensorArrayWrite.create(scope, handle, index, value, flowIn);
+  public <T extends TNumber, U extends TType> ResourceScatterNdUpdate resourceScatterNdUpdate(
+      Operand<?> ref, Operand<T> indices, Operand<U> updates,
+      ResourceScatterNdUpdate.Options... options) {
+    return ResourceScatterNdUpdate.create(scope, ref, indices, updates, options);
   }
 
   /**
-   * Concats all tensors in the list along the 0th dimension.
+   * Subtracts sparse updates from the variable referenced by `resource`.
    *  <p>
-   *  Requires that all tensors have the same shape except the first dimension.
+   *  This operation computes
    *  <p>
-   *  input_handle: The input list.
-   *  element_shape: The shape of the uninitialized elements in the list. If the first
-   *    dimension is not -1, it is assumed that all list elements have the same
-   *    leading dim.
-   *  leading_dims: The list of leading dims of uninitialized list elements. Used if
-   *    the leading dim of input_handle.element_shape or the element_shape input arg
-   *    is not already set.
-   *  tensor: The concated result.
-   *  lengths: Output tensor containing sizes of the 0th dimension of tensors in the list, used for computing the gradient.
+   *      # Scalar indices
+   *      ref[indices, ...] -= updates[...]
+   *  <p>
+   *      # Vector indices (for each i)
+   *      ref[indices[i], ...] -= updates[i, ...]
+   *  <p>
+   *      # High rank indices (for each i, ..., j)
+   *      ref[indices[i, ..., j], ...] -= updates[i, ..., j, ...]
+   *  <p>
+   *  Duplicate entries are handled correctly: if multiple `indices` reference
+   *  the same location, their contributions add.
+   *  <p>
+   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+   *  <p>
+   *  <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>
    *
-   * @param <U> data type for {@code tensor()} output
-   * @param inputHandle
-   * @param elementShape
-   * @param leadingDims
-   * @param elementDtype
-   * @return a new instance of TensorListConcat
+   * @param resource Should be from a `Variable` node.
+   * @param indices A tensor of indices into the first dimension of `ref`.
+   * @param updates A tensor of updated values to add to `ref`.
+   * @return a new instance of ResourceScatterSub
    */
-  public <U extends TType, T extends TNumber> TensorListConcat<U> tensorListConcat(
-      Operand<?> inputHandle, Operand<T> elementShape, Operand<TInt64> leadingDims,
-      DataType<U> elementDtype) {
-    return TensorListConcat.create(scope, inputHandle, elementShape, leadingDims, elementDtype);
+  public <T extends TNumber, U extends TType> ResourceScatterSub resourceScatterSub(
+      Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+    return ResourceScatterSub.create(scope, resource, indices, updates);
   }
 
   /**
+   * Assigns sparse updates to the variable referenced by `resource`.
+   *  <p>
+   *  This operation computes
+   *  <p>
+   *      # Scalar indices
+   *      ref[indices, ...] = updates[...]
+   *  <p>
+   *      # Vector indices (for each i)
+   *      ref[indices[i], ...] = updates[i, ...]
+   *  <p>
+   *      # High rank indices (for each i, ..., j)
+   *      ref[indices[i, ..., j], ...] = updates[i, ..., j, ...]
    *
-   * @param inputA
-   * @param inputB
-   * @param elementDtype
-   * @return a new instance of TensorListConcatLists
+   * @param resource Should be from a `Variable` node.
+   * @param indices A tensor of indices into the first dimension of `ref`.
+   * @param updates A tensor of updated values to add to `ref`.
+   * @return a new instance of ResourceScatterUpdate
    */
-  public <T extends TType> TensorListConcatLists tensorListConcatLists(Operand<?> inputA,
-      Operand<?> inputB, DataType<T> elementDtype) {
-    return TensorListConcatLists.create(scope, inputA, inputB, elementDtype);
+  public <T extends TNumber, U extends TType> ResourceScatterUpdate resourceScatterUpdate(
+      Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+    return ResourceScatterUpdate.create(scope, resource, indices, updates);
   }
 
   /**
-   * The shape of the elements of the given list, as a tensor.
+   * Assign `value` to the sliced l-value reference of `ref`.
    *  <p>
-   *    input_handle: the list
-   *    element_shape: the shape of elements of the list
+   *  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`.
+   *  <p>
+   *  NOTE this op currently does not support broadcasting and so `value`'s
+   *  shape must be exactly the shape produced by the slice of `ref`.
    *
-   * @param <T> data type for {@code elementShape()} output
-   * @param inputHandle
-   * @param shapeType
-   * @return a new instance of TensorListElementShape
+   * @param ref
+   * @param begin
+   * @param end
+   * @param strides
+   * @param value
+   * @param options carries optional attributes values
+   * @return a new instance of ResourceStridedSliceAssign
    */
-  public <T extends TNumber> TensorListElementShape<T> tensorListElementShape(
-      Operand<?> inputHandle, DataType<T> shapeType) {
-    return TensorListElementShape.create(scope, inputHandle, shapeType);
+  public <T extends TNumber, U extends TType> ResourceStridedSliceAssign resourceStridedSliceAssign(
+      Operand<?> ref, Operand<T> begin, Operand<T> end, Operand<T> strides, Operand<U> value,
+      ResourceStridedSliceAssign.Options... options) {
+    return ResourceStridedSliceAssign.create(scope, ref, begin, end, strides, value, options);
   }
 
   /**
-   * Creates a TensorList which, when stacked, has the value of `tensor`.
+   * Reverses specific dimensions of a tensor.
    *  <p>
-   *  Each tensor in the result list corresponds to one row of the input tensor.
+   *  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.
    *  <p>
-   *  tensor: The input tensor.
-   *  output_handle: The list.
+   *  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`.
+   *  <p>
+   *  `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.
+   *  <p>
+   *  For example:
+   *  <pre>{@code
+   *  # 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]
    *
-   * @param tensor
-   * @param elementShape
-   * @return a new instance of TensorListFromTensor
+   *  # '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]]]]
+   *  }</pre>
+   *
+   * @param <T> data type for {@code output()} output
+   * @param tensor Up to 8-D.
+   * @param axis 1-D. The indices of the dimensions to reverse. Must be in the range
+   *  `[-rank(tensor), rank(tensor))`.
+   * @return a new instance of Reverse
    */
-  public <T extends TType, U extends TNumber> TensorListFromTensor tensorListFromTensor(
-      Operand<T> tensor, Operand<U> elementShape) {
-    return TensorListFromTensor.create(scope, tensor, elementShape);
+  public <T extends TType, U extends TNumber> Reverse<T> reverse(Operand<T> tensor,
+      Operand<U> axis) {
+    return Reverse.create(scope, tensor, axis);
   }
 
   /**
-   * Creates a Tensor by indexing into the TensorList.
+   * Reverses variable length slices.
    *  <p>
-   *  Each row in the produced Tensor corresponds to the element in the TensorList
-   *  specified by the given index (see `tf.gather`).  
+   *  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`.
    *  <p>
-   *  input_handle: The input tensor list.
-   *  indices: The indices used to index into the list.
-   *  values: The tensor.
+   *  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]`.
+   *  <p>
+   *  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.
+   *  <p>
+   *  For example:
+   *  <pre>{@code
+   *  # Given this:
+   *  batch_dim = 0
+   *  seq_dim = 1
+   *  input.dims = (4, 8, ...)
+   *  seq_lengths = [7, 2, 3, 5]
    *
-   * @param <T> data type for {@code values()} output
-   * @param inputHandle
-   * @param indices
-   * @param elementShape
-   * @param elementDtype
-   * @return a new instance of TensorListGather
-   */
-  public <T extends TType> TensorListGather<T> tensorListGather(Operand<?> inputHandle,
-      Operand<TInt32> indices, Operand<TInt32> elementShape, DataType<T> elementDtype) {
-    return TensorListGather.create(scope, inputHandle, indices, elementShape, elementDtype);
-  }
-
-  /**
+   *  # 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, :, ...]
    *
-   * @param <T> data type for {@code item()} output
-   * @param inputHandle
-   * @param index
-   * @param elementShape
-   * @param elementDtype
-   * @return a new instance of TensorListGetItem
+   *  # 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:, :, ...]
+   *  }</pre>
+   *  In contrast, if:
+   *  <pre>{@code
+   *  # 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, :, ...]
+   *  }</pre>
+   *
+   * @param <T> data type for {@code output()} output
+   * @param input The input to reverse.
+   * @param seqLengths 1-D with length `input.dims(batch_dim)` and
+   *  `max(seq_lengths) <= input.dims(seq_dim)`
+   * @param seqDim The dimension which is partially reversed.
+   * @param options carries optional attributes values
+   * @return a new instance of ReverseSequence
    */
-  public <T extends TType> TensorListGetItem<T> tensorListGetItem(Operand<?> inputHandle,
-      Operand<TInt32> index, Operand<TInt32> elementShape, DataType<T> elementDtype) {
-    return TensorListGetItem.create(scope, inputHandle, index, elementShape, elementDtype);
+  public <T extends TType, U extends TNumber> ReverseSequence<T> reverseSequence(Operand<T> input,
+      Operand<U> seqLengths, Long seqDim, ReverseSequence.Options... options) {
+    return ReverseSequence.create(scope, input, seqLengths, seqDim, options);
   }
 
   /**
-   * Returns the number of tensors in the input tensor list.
+   * Rolls the elements of a tensor along an axis.
    *  <p>
-   *  input_handle: the input list
-   *  length: the number of tensors in the list
+   *  The elements are shifted positively (towards larger indices) by the offset of
+   *  `shift` along the dimension of `axis`. Negative `shift` values will shift
+   *  elements in the opposite direction. Elements that roll passed the last position
+   *  will wrap around to the first and vice versa. Multiple shifts along multiple
+   *  axes may be specified.
+   *  <p>
+   *  For example:
+   *  <pre>{@code
+   *  # 't' is [0, 1, 2, 3, 4]
+   *  roll(t, shift=2, axis=0) ==> [3, 4, 0, 1, 2]
    *
-   * @param inputHandle
-   * @return a new instance of TensorListLength
+   *  # shifting along multiple dimensions
+   *  # 't' is [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
+   *  roll(t, shift=[1, -2], axis=[0, 1]) ==> [[7, 8, 9, 5, 6], [2, 3, 4, 0, 1]]
+   *
+   *  # shifting along the same axis multiple times
+   *  # 't' is [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
+   *  roll(t, shift=[2, -3], axis=[1, 1]) ==> [[1, 2, 3, 4, 0], [6, 7, 8, 9, 5]]
+   *  }</pre>
+   *
+   * @param <T> data type for {@code output()} output
+   * @param input
+   * @param shift Dimension must be 0-D or 1-D. `shift[i]` specifies the number of places by which
+   *  elements are shifted positively (towards larger indices) along the dimension
+   *  specified by `axis[i]`. Negative shifts will roll the elements in the opposite
+   *  direction.
+   * @param axis Dimension must be 0-D or 1-D. `axis[i]` specifies the dimension that the shift
+   *  `shift[i]` should occur. If the same axis is referenced more than once, the
+   *  total shift for that axis will be the sum of all the shifts that belong to that
+   *  axis.
+   * @return a new instance of Roll
    */
-  public TensorListLength tensorListLength(Operand<?> inputHandle) {
-    return TensorListLength.create(scope, inputHandle);
+  public <T extends TType, U extends TNumber, V extends TNumber> Roll<T> roll(Operand<T> input,
+      Operand<U> shift, Operand<V> axis) {
+    return Roll.create(scope, input, shift, axis);
   }
 
   /**
-   * Returns the last element of the input list as well as a list with all but that element.
+   * Perform batches of RPC requests.
    *  <p>
-   *  Fails if the list is empty.
+   *  This op asynchronously performs either a single RPC request, or a batch
+   *  of requests.  RPC requests are defined by three main parameters:
    *  <p>
-   *  input_handle: the input list
-   *  tensor: the withdrawn last element of the list
-   *  element_dtype: the type of elements in the list
-   *  element_shape: the shape of the output tensor
+   *    - `address` (the host+port or BNS address of the request)
+   *    - `method` (the RPC method name for the request)
+   *    - `request` (the serialized proto string, or vector of strings,
+   *       of the RPC request argument).
+   *  <p>
+   *  For example, if you have an RPC service running on port localhost:2345,
+   *  and its interface is configured with the following proto declaration:
+   *  <pre>{@code
+   *  service MyService {
+   *    rpc MyMethod(MyRequestProto) returns (MyResponseProto) {
+   *    }
+   *  };
+   *  }</pre>
+   *  then call this op with arguments:
+   *  <pre>{@code
+   *  address = "localhost:2345"
+   *  method = "MyService/MyMethod"
+   *  }</pre>
+   *  The `request` tensor is a string tensor representing serialized `MyRequestProto`
+   *  strings; and the output string tensor `response` will have the same shape
+   *  and contain (upon successful completion) corresponding serialized
+   *  `MyResponseProto` strings.
+   *  <p>
+   *  For example, to send a single, empty, `MyRequestProto`, call
+   *  this op with `request = ""`.  To send 5 <b>parallel</b> empty requests,
+   *  call this op with `request = ["", "", "", "", ""]`.
+   *  <p>
+   *  More generally, one can create a batch of `MyRequestProto` serialized protos
+   *  from regular batched tensors using the `encode_proto` op, and convert
+   *  the response `MyResponseProto` serialized protos to batched tensors
+   *  using the `decode_proto` op.
+   *  <p>
+   *  <b>NOTE</b> Working with serialized proto strings is faster than instantiating
+   *  actual proto objects in memory, so no performance degradation is expected
+   *  compared to writing custom kernels for this workflow.
+   *  <p>
+   *  If the connection fails or the remote worker returns an error
+   *  status, the op reraises this exception locally.
+   *  <p>
+   *  See the `TryRpc` op if you prefer to handle RPC failures manually in the graph.
    *
-   * @param <T> data type for {@code tensor()} output
-   * @param inputHandle
-   * @param elementShape
-   * @param elementDtype
-   * @return a new instance of TensorListPopBack
+   * @param address `0-D` or `1-D`.  The address (i.e. host_name:port) of the RPC server.
+   *  If this tensor has more than 1 element, then multiple parallel rpc requests
+   *  are sent.  This argument broadcasts with `method` and `request`.
+   * @param method `0-D` or `1-D`.  The method address on the RPC server.
+   *  If this tensor has more than 1 element, then multiple parallel rpc requests
+   *  are sent.  This argument broadcasts with `address` and `request`.
+   * @param request `0-D` or `1-D`.  Serialized proto strings: the rpc request argument.
+   *  If this tensor has more than 1 element, then multiple parallel rpc requests
+   *  are sent.  This argument broadcasts with `address` and `method`.
+   * @param options carries optional attributes values
+   * @return a new instance of Rpc
    */
-  public <T extends TType> TensorListPopBack<T> tensorListPopBack(Operand<?> inputHandle,
-      Operand<TInt32> elementShape, DataType<T> elementDtype) {
-    return TensorListPopBack.create(scope, inputHandle, elementShape, elementDtype);
+  public Rpc rpc(Operand<TString> address, Operand<TString> method, Operand<TString> request,
+      Rpc.Options... options) {
+    return Rpc.create(scope, address, method, request, options);
   }
 
   /**
-   * Returns a list which has the passed-in `Tensor` as last element and the other elements of the given list in `input_handle`.
+   * Adds sparse updates to a variable reference.
    *  <p>
-   *  tensor: The tensor to put on the list.
-   *  input_handle: The old list.
-   *  output_handle: A list with the elements of the old list followed by tensor.
-   *  element_dtype: the type of elements in the list.
-   *  element_shape: a shape compatible with that of elements in the list.
+   *  This operation computes
+   *  <p>
+   *      # Scalar indices
+   *      ref[indices, ...] += updates[...]
+   *  <p>
+   *      # Vector indices (for each i)
+   *      ref[indices[i], ...] += updates[i, ...]
+   *  <p>
+   *      # High rank indices (for each i, ..., j)
+   *      ref[indices[i, ..., j], ...] += updates[i, ..., j, ...]
+   *  <p>
+   *  This operation outputs `ref` after the update is done.
+   *  This makes it easier to chain operations that need to use the reset value.
+   *  <p>
+   *  Duplicate entries are handled correctly: if multiple `indices` reference
+   *  the same location, their contributions add.
+   *  <p>
+   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+   *  <p>
+   *  <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>
    *
-   * @param inputHandle
-   * @param tensor
-   * @return a new instance of TensorListPushBack
+   * @param <T> data type for {@code outputRef()} output
+   * @param ref Should be from a `Variable` node.
+   * @param indices A tensor of indices into the first dimension of `ref`.
+   * @param updates A tensor of updated values to add to `ref`.
+   * @param options carries optional attributes values
+   * @return a new instance of ScatterAdd
    */
-  public <T extends TType> TensorListPushBack tensorListPushBack(Operand<?> inputHandle,
-      Operand<T> tensor) {
-    return TensorListPushBack.create(scope, inputHandle, tensor);
+  public <T extends TType, U extends TNumber> ScatterAdd<T> scatterAdd(Operand<T> ref,
+      Operand<U> indices, Operand<T> updates, ScatterAdd.Options... options) {
+    return ScatterAdd.create(scope, ref, indices, updates, options);
   }
 
   /**
+   * Divides a variable reference by sparse updates.
+   *  <p>
+   *  This operation computes
+   *  <pre>{@code
+   *      # Scalar indices
+   *      ref[indices, ...] /= updates[...]
    *
-   * @param inputHandles
-   * @param tensor
-   * @return a new instance of TensorListPushBackBatch
+   *      # Vector indices (for each i)
+   *      ref[indices[i], ...] /= updates[i, ...]
+   *
+   *      # High rank indices (for each i, ..., j)
+   *      ref[indices[i, ..., j], ...] /= updates[i, ..., j, ...]
+   *  }</pre>
+   *  This operation outputs `ref` after the update is done.
+   *  This makes it easier to chain operations that need to use the reset value.
+   *  <p>
+   *  Duplicate entries are handled correctly: if multiple `indices` reference
+   *  the same location, their contributions divide.
+   *  <p>
+   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+   *
+   * @param <T> data type for {@code outputRef()} output
+   * @param ref Should be from a `Variable` node.
+   * @param indices A tensor of indices into the first dimension of `ref`.
+   * @param updates A tensor of values that `ref` is divided by.
+   * @param options carries optional attributes values
+   * @return a new instance of ScatterDiv
    */
-  public <T extends TType> TensorListPushBackBatch tensorListPushBackBatch(Operand<?> inputHandles,
-      Operand<T> tensor) {
-    return TensorListPushBackBatch.create(scope, inputHandles, tensor);
+  public <T extends TType, U extends TNumber> ScatterDiv<T> scatterDiv(Operand<T> ref,
+      Operand<U> indices, Operand<T> updates, ScatterDiv.Options... options) {
+    return ScatterDiv.create(scope, ref, indices, updates, options);
   }
 
   /**
-   * List of the given size with empty elements.
+   * Reduces sparse updates into a variable reference using the `max` operation.
    *  <p>
-   *  element_shape: the shape of the future elements of the list
-   *  num_elements: the number of elements to reserve
-   *  handle: the output list
-   *  element_dtype: the desired type of elements in the list.
-   *
-   * @param elementShape
-   * @param numElements
-   * @param elementDtype
-   * @return a new instance of TensorListReserve
-   */
-  public <T extends TNumber, U extends TType> TensorListReserve tensorListReserve(
-      Operand<T> elementShape, Operand<TInt32> numElements, DataType<U> elementDtype) {
-    return TensorListReserve.create(scope, elementShape, numElements, elementDtype);
-  }
-
-  /**
-   * Resizes the list.
+   *  This operation computes
    *  <p>
-   *
-   *  input_handle: the input list
-   *  size: size of the output list
-   *
-   * @param inputHandle
-   * @param size
-   * @return a new instance of TensorListResize
-   */
-  public TensorListResize tensorListResize(Operand<?> inputHandle, Operand<TInt32> size) {
-    return TensorListResize.create(scope, inputHandle, size);
-  }
-
-  /**
-   * Creates a TensorList by indexing into a Tensor.
+   *      # Scalar indices
+   *      ref[indices, ...] = max(ref[indices, ...], updates[...])
    *  <p>
-   *  Each member of the TensorList corresponds to one row of the input tensor,
-   *  specified by the given index (see `tf.gather`).
+   *      # Vector indices (for each i)
+   *      ref[indices[i], ...] = max(ref[indices[i], ...], updates[i, ...])
    *  <p>
-   *  tensor: The input tensor.
-   *  indices: The indices used to index into the list.
-   *  element_shape: The shape of the elements in the list (can be less specified than
-   *    the shape of the tensor).
-   *  num_elements: The size of the output list. Must be large enough to accommodate
-   *    the largest index in indices. If -1, the list is just large enough to include
-   *    the largest index in indices.
-   *  output_handle: The TensorList.
-   *
-   * @param tensor
-   * @param indices
-   * @param elementShape
-   * @param numElements
-   * @return a new instance of TensorListScatter
-   */
-  public <T extends TType, U extends TNumber> TensorListScatter tensorListScatter(Operand<T> tensor,
-      Operand<TInt32> indices, Operand<U> elementShape, Operand<TInt32> numElements) {
-    return TensorListScatter.create(scope, tensor, indices, elementShape, numElements);
-  }
-
-  /**
-   * Scatters tensor at indices in an input list.
+   *      # High rank indices (for each i, ..., j)
+   *      ref[indices[i, ..., j], ...] = max(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
    *  <p>
-   *  Each member of the TensorList corresponds to one row of the input tensor,
-   *  specified by the given index (see `tf.gather`).
+   *  This operation outputs `ref` after the update is done.
+   *  This makes it easier to chain operations that need to use the reset value.
    *  <p>
-   *  input_handle: The list to scatter into.
-   *  tensor: The input tensor.
-   *  indices: The indices used to index into the list.
-   *  output_handle: The TensorList.
-   *
-   * @param inputHandle
-   * @param tensor
-   * @param indices
-   * @return a new instance of TensorListScatterIntoExistingList
-   */
-  public <T extends TType> TensorListScatterIntoExistingList tensorListScatterIntoExistingList(
-      Operand<?> inputHandle, Operand<T> tensor, Operand<TInt32> indices) {
-    return TensorListScatterIntoExistingList.create(scope, inputHandle, tensor, indices);
-  }
-
-  /**
+   *  Duplicate entries are handled correctly: if multiple `indices` reference
+   *  the same location, their contributions combine.
+   *  <p>
+   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+   *  <p>
+   *  <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>
    *
-   * @param inputHandle
-   * @param index
-   * @param item
-   * @return a new instance of TensorListSetItem
+   * @param <T> data type for {@code outputRef()} output
+   * @param ref Should be from a `Variable` node.
+   * @param indices A tensor of indices into the first dimension of `ref`.
+   * @param updates A tensor of updated values to reduce into `ref`.
+   * @param options carries optional attributes values
+   * @return a new instance of ScatterMax
    */
-  public <T extends TType> TensorListSetItem tensorListSetItem(Operand<?> inputHandle,
-      Operand<TInt32> index, Operand<T> item) {
-    return TensorListSetItem.create(scope, inputHandle, index, item);
+  public <T extends TNumber, U extends TNumber> ScatterMax<T> scatterMax(Operand<T> ref,
+      Operand<U> indices, Operand<T> updates, ScatterMax.Options... options) {
+    return ScatterMax.create(scope, ref, indices, updates, options);
   }
 
   /**
-   * Splits a tensor into a list.
+   * Reduces sparse updates into a variable reference using the `min` operation.
    *  <p>
-   *  list[i] corresponds to lengths[i] tensors from the input tensor.
-   *  The tensor must have rank at least 1 and contain exactly sum(lengths) elements.
+   *  This operation computes
    *  <p>
-   *  tensor: The input tensor.
-   *  element_shape: A shape compatible with that of elements in the tensor.
-   *  lengths: Vector of sizes of the 0th dimension of tensors in the list.
-   *  output_handle: The list.
+   *      # Scalar indices
+   *      ref[indices, ...] = min(ref[indices, ...], updates[...])
+   *  <p>
+   *      # Vector indices (for each i)
+   *      ref[indices[i], ...] = min(ref[indices[i], ...], updates[i, ...])
+   *  <p>
+   *      # High rank indices (for each i, ..., j)
+   *      ref[indices[i, ..., j], ...] = min(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
+   *  <p>
+   *  This operation outputs `ref` after the update is done.
+   *  This makes it easier to chain operations that need to use the reset value.
+   *  <p>
+   *  Duplicate entries are handled correctly: if multiple `indices` reference
+   *  the same location, their contributions combine.
+   *  <p>
+   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+   *  <p>
+   *  <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>
    *
-   * @param tensor
-   * @param elementShape
-   * @param lengths
-   * @return a new instance of TensorListSplit
+   * @param <T> data type for {@code outputRef()} output
+   * @param ref Should be from a `Variable` node.
+   * @param indices A tensor of indices into the first dimension of `ref`.
+   * @param updates A tensor of updated values to reduce into `ref`.
+   * @param options carries optional attributes values
+   * @return a new instance of ScatterMin
    */
-  public <T extends TType, U extends TNumber> TensorListSplit tensorListSplit(Operand<T> tensor,
-      Operand<U> elementShape, Operand<TInt64> lengths) {
-    return TensorListSplit.create(scope, tensor, elementShape, lengths);
+  public <T extends TNumber, U extends TNumber> ScatterMin<T> scatterMin(Operand<T> ref,
+      Operand<U> indices, Operand<T> updates, ScatterMin.Options... options) {
+    return ScatterMin.create(scope, ref, indices, updates, options);
   }
 
   /**
-   * Stacks all tensors in the list.
+   * Multiplies sparse updates into a variable reference.
    *  <p>
-   *  Requires that all tensors have the same shape.
+   *  This operation computes
+   *  <pre>{@code
+   *      # 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, ...]
+   *  }</pre>
+   *  This operation outputs `ref` after the update is done.
+   *  This makes it easier to chain operations that need to use the reset value.
    *  <p>
-   *  input_handle: the input list
-   *  tensor: the gathered result
-   *  num_elements: optional. If not -1, the number of elements in the list.
+   *  Duplicate entries are handled correctly: if multiple `indices` reference
+   *  the same location, their contributions multiply.
+   *  <p>
+   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
    *
-   * @param <T> data type for {@code tensor()} output
-   * @param inputHandle
-   * @param elementShape
-   * @param elementDtype
+   * @param <T> data type for {@code outputRef()} output
+   * @param ref Should be from a `Variable` node.
+   * @param indices A tensor of indices into the first dimension of `ref`.
+   * @param updates A tensor of updated values to multiply to `ref`.
    * @param options carries optional attributes values
-   * @return a new instance of TensorListStack
+   * @return a new instance of ScatterMul
    */
-  public <T extends TType> TensorListStack<T> tensorListStack(Operand<?> inputHandle,
-      Operand<TInt32> elementShape, DataType<T> elementDtype, TensorListStack.Options... options) {
-    return TensorListStack.create(scope, inputHandle, elementShape, elementDtype, options);
+  public <T extends TType, U extends TNumber> ScatterMul<T> scatterMul(Operand<T> ref,
+      Operand<U> indices, Operand<T> updates, ScatterMul.Options... options) {
+    return ScatterMul.create(scope, ref, indices, updates, options);
   }
 
   /**
-   * Adds sparse `updates` to an existing tensor according to `indices`.
+   * Scatter `updates` into a new tensor according to `indices`.
    *  <p>
-   *  This operation creates a new tensor by adding sparse `updates` to the passed
-   *  in `tensor`.
-   *  This operation is very similar to `tf.scatter_nd_add`, except that the updates
-   *  are added onto an existing tensor (as opposed to a variable). If the memory
-   *  for the existing tensor cannot be re-used, a copy is made and updated.
+   *  Creates a new tensor by applying sparse `updates` to individual values or
+   *  slices within a tensor (initially zero for numeric, empty for string) 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.
+   *  <p>
+   *  This operation is similar to tensor_scatter_add, except that the tensor is
+   *  zero-initialized. Calling `tf.scatter_nd(indices, values, shape)` is identical
+   *  to `tensor_scatter_add(tf.zeros(shape, values.dtype), indices, values)`
+   *  <p>
+   *  If `indices` contains duplicates, then their updates are accumulated (summed).
+   *  <p>
+   *  <b>WARNING</b>: The order in which updates are applied is nondeterministic, so the
+   *  output will be nondeterministic if `indices` contains duplicates -- because
+   *  of some numerical approximation issues, numbers summed in different order
+   *  may yield different results.
    *  <p>
    *  `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`:
@@ -5820,1492 +4882,2431 @@ public <T extends TType> TensorListStack<T> tensorListStack(Operand<?> inputHand
    *  <p>
    *      indices.shape[:-1] + shape[indices.shape[-1]:]
    *  <p>
-   *  The simplest form of tensor_scatter_add is to add individual elements to a
-   *  tensor by index. For example, say we want to add 4 elements in a rank-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.
    *  <p>
-   *  In Python, this scatter add operation would look like this:
+   *  <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>
+   *  <p>
+   *  In Python, this scatter operation would look like this:
    *  <pre>{@code
    *      indices = tf.constant([[4], [3], [1], [7]])
    *      updates = tf.constant([9, 10, 11, 12])
-   *      tensor = tf.ones([8], dtype=tf.int32)
-   *      updated = tf.tensor_scatter_nd_add(tensor, indices, updates)
-   *      print(updated)
+   *      shape = tf.constant([8])
+   *      scatter = tf.scatter_nd(indices, updates, shape)
+   *      print(scatter)
    *  }</pre>
    *  The resulting tensor would look like this:
    *  <p>
-   *      [1, 12, 1, 11, 10, 1, 1, 13]
+   *      [0, 11, 0, 10, 9, 0, 0, 12]
    *  <p>
    *  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.
    *  <p>
-   *  In Python, this scatter add operation would look like this:
+   *  <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>
+   *  <p>
+   *  In Python, this scatter operation would look like this:
    *  <pre>{@code
    *      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]]])
-   *      tensor = tf.ones([4, 4, 4],dtype=tf.int32)
-   *      updated = tf.tensor_scatter_nd_add(tensor, indices, updates)
-   *      print(updated)
+   *      shape = tf.constant([4, 4, 4])
+   *      scatter = tf.scatter_nd(indices, updates, shape)
+   *      print(scatter)
    *  }</pre>
    *  The resulting tensor would look like this:
    *  <p>
-   *      [[[6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8], [9, 9, 9, 9]],
-   *       [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
-   *       [[6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8], [9, 9, 9, 9]],
-   *       [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]
+   *      [[[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]]]
    *  <p>
    *  Note that on CPU, if an out of bound index is found, an error is returned.
    *  On GPU, if an out of bound index is found, the index is ignored.
    *
-   * @param <T> data type for {@code output()} output
-   * @param tensor Tensor to copy/update.
+   * @param <U> data type for {@code output()} output
    * @param indices Index tensor.
    * @param updates Updates to scatter into output.
-   * @return a new instance of TensorScatterNdAdd
-   */
-  public <T extends TType, U extends TNumber> TensorScatterNdAdd<T> tensorScatterNdAdd(
-      Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
-    return TensorScatterNdAdd.create(scope, tensor, indices, updates);
+   * @param shape 1-D. The shape of the resulting tensor.
+   * @return a new instance of ScatterNd
+   */
+  public <U extends TType, T extends TNumber> ScatterNd<U> scatterNd(Operand<T> indices,
+      Operand<U> updates, Operand<T> shape) {
+    return ScatterNd.create(scope, indices, updates, shape);
   }
 
   /**
-   * Subtracts sparse `updates` from an existing tensor according to `indices`.
-   *  <p>
-   *  This operation creates a new tensor by subtracting sparse `updates` from the
-   *  passed in `tensor`.
-   *  This operation is very similar to `tf.scatter_nd_sub`, except that the updates
-   *  are subtracted from an existing tensor (as opposed to a variable). If the memory
-   *  for the existing tensor cannot be re-used, a copy is made and updated.
-   *  <p>
-   *  `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`:
-   *  <p>
-   *      indices.shape[-1] <= shape.rank
+   * Applies sparse addition to individual values or slices in a Variable.
    *  <p>
-   *  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
+   *  `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
    *  <p>
-   *      indices.shape[:-1] + shape[indices.shape[-1]:]
+   *  `indices` must be integer tensor, containing indices into `ref`.
+   *  It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
    *  <p>
-   *  The simplest form of tensor_scatter_sub is to subtract individual elements
-   *  from a tensor by index. For example, say we want to insert 4 scattered elements
-   *  in a rank-1 tensor with 8 elements.
+   *  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`.
    *  <p>
-   *  In Python, this scatter subtract operation would look like this:
+   *  `updates` is `Tensor` of rank `Q-1+P-K` with shape:
    *  <pre>{@code
-   *      indices = tf.constant([[4], [3], [1], [7]])
-   *      updates = tf.constant([9, 10, 11, 12])
-   *      tensor = tf.ones([8], dtype=tf.int32)
-   *      updated = tf.tensor_scatter_nd_sub(tensor, indices, updates)
-   *      print(updated)
+   *  [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]]
    *  }</pre>
-   *  The resulting tensor would look like this:
-   *  <p>
-   *      [1, -10, 1, -9, -8, 1, 1, -11]
-   *  <p>
-   *  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.
-   *  <p>
-   *  In Python, this scatter add operation would look like this:
+   *  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:
    *  <pre>{@code
-   *      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]]])
-   *      tensor = tf.ones([4, 4, 4],dtype=tf.int32)
-   *      updated = tf.tensor_scatter_nd_sub(tensor, indices, updates)
-   *      print(updated)
+   *  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)
    *  }</pre>
-   *  The resulting tensor would look like this:
+   *  The resulting update to ref would look like this:
    *  <p>
-   *      [[[-4, -4, -4, -4], [-5, -5, -5, -5], [-6, -6, -6, -6], [-7, -7, -7, -7]],
-   *       [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
-   *       [[-4, -4, -4, -4], [-5, -5, -5, -5], [-6, -6, -6, -6], [-7, -7, -7, -7]],
-   *       [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]
+   *      [1, 13, 3, 14, 14, 6, 7, 20]
    *  <p>
-   *  Note that on CPU, if an out of bound index is found, an error is returned.
-   *  On GPU, if an out of bound index is found, the index is ignored.
+   *  See `tf.scatter_nd` for more details about how to make updates to
+   *  slices.
    *
-   * @param <T> data type for {@code output()} output
-   * @param tensor Tensor to copy/update.
-   * @param indices Index tensor.
-   * @param updates Updates to scatter into output.
-   * @return a new instance of TensorScatterNdSub
+   * @param <T> data type for {@code outputRef()} output
+   * @param ref A mutable Tensor. Should be from a Variable node.
+   * @param indices A Tensor. Must be one of the following types: int32, int64.
+   *  A tensor of indices into ref.
+   * @param updates A Tensor. Must have the same type as ref. A tensor of updated values
+   *  to add to ref.
+   * @param options carries optional attributes values
+   * @return a new instance of ScatterNdAdd
    */
-  public <T extends TType, U extends TNumber> TensorScatterNdSub<T> tensorScatterNdSub(
-      Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
-    return TensorScatterNdSub.create(scope, tensor, indices, updates);
+  public <T extends TType, U extends TNumber> ScatterNdAdd<T> scatterNdAdd(Operand<T> ref,
+      Operand<U> indices, Operand<T> updates, ScatterNdAdd.Options... options) {
+    return ScatterNdAdd.create(scope, ref, indices, updates, options);
   }
 
   /**
-   * Scatter `updates` into an existing tensor according to `indices`.
-   *  <p>
-   *  This operation creates a new tensor by applying sparse `updates` to the passed
-   *  in `tensor`.
-   *  This operation is very similar to `tf.scatter_nd`, except that the updates are
-   *  scattered onto an existing tensor (as opposed to a zero-tensor). If the memory
-   *  for the existing tensor cannot be re-used, a copy is made and updated.
-   *  <p>
-   *  If `indices` contains duplicates, then their updates are accumulated (summed).
+   * Applies sparse addition to `input` using individual values or slices
    *  <p>
-   *  <b>WARNING</b>: The order in which updates are applied is nondeterministic, so the
-   *  output will be nondeterministic if `indices` contains duplicates -- because
-   *  of some numerical approximation issues, numbers summed in different order
-   *  may yield different results.
+   *  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`.
    *  <p>
-   *  `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`:
+   *  `input` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
    *  <p>
-   *      indices.shape[-1] <= shape.rank
+   *  `indices` must be integer tensor, containing indices into `input`.
+   *  It must be shape \\([d_0, ..., d_{Q-2}, K]\\) where `0 < K <= P`.
    *  <p>
-   *  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
+   *  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`.
    *  <p>
-   *      indices.shape[:-1] + shape[indices.shape[-1]:]
+   *  `updates` is `Tensor` of rank `Q-1+P-K` with shape:
    *  <p>
-   *  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.
+   *  $$[d_0, ..., d_{Q-2}, input.shape[K], ..., input.shape[P-1]].$$
    *  <p>
-   *  <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>
+   *  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:
    *  <p>
-   *  In Python, this scatter operation would look like this:
-   *  <pre>{@code
+   *      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])
-   *      tensor = tf.ones([8], dtype=tf.int32)
-   *      updated = tf.tensor_scatter_nd_update(tensor, indices, updates)
-   *      print(updated)
-   *  }</pre>
-   *  The resulting tensor would look like this:
-   *  <p>
-   *      [1, 11, 1, 10, 9, 1, 1, 12]
-   *  <p>
-   *  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.
+   *      output = tf.scatter_nd_non_aliasing_add(input, indices, updates)
+   *      with tf.Session() as sess:
+   *        print(sess.run(output))
    *  <p>
-   *  In Python, this scatter operation would look like this:
-   *  <pre>{@code
-   *      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]]])
-   *      tensor = tf.ones([4, 4, 4],dtype=tf.int32)
-   *      updated = tf.tensor_scatter_nd_update(tensor, indices, updates)
-   *      print(updated)
-   *  }</pre>
-   *  The resulting tensor would look like this:
+   *  The resulting value `output` would look like this:
    *  <p>
-   *      [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
-   *       [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
-   *       [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
-   *       [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]
+   *      [1, 13, 3, 14, 14, 6, 7, 20]
    *  <p>
-   *  Note that on CPU, if an out of bound index is found, an error is returned.
-   *  On GPU, if an out of bound index is found, the index is ignored.
+   *  See `tf.scatter_nd` for more details about how to make updates to slices.
    *
    * @param <T> data type for {@code output()} output
-   * @param tensor Tensor to copy/update.
-   * @param indices Index tensor.
-   * @param updates Updates to scatter into output.
-   * @return a new instance of TensorScatterNdUpdate
+   * @param input A Tensor.
+   * @param indices A Tensor. Must be one of the following types: `int32`, `int64`.
+   *  A tensor of indices into `input`.
+   * @param updates A Tensor. Must have the same type as ref. A tensor of updated values
+   *  to add to `input`.
+   * @return a new instance of ScatterNdNonAliasingAdd
    */
-  public <T extends TType, U extends TNumber> TensorScatterNdUpdate<T> tensorScatterNdUpdate(
-      Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
-    return TensorScatterNdUpdate.create(scope, tensor, indices, updates);
+  public <T extends TType, U extends TNumber> ScatterNdNonAliasingAdd<T> scatterNdNonAliasingAdd(
+      Operand<T> input, Operand<U> indices, Operand<T> updates) {
+    return ScatterNdNonAliasingAdd.create(scope, input, indices, updates);
   }
 
   /**
-   * Assign `value` to the sliced l-value reference of `input`.
+   * Applies sparse subtraction to individual values or slices in a Variable.
    *  <p>
-   *  The values of `value` are assigned to the positions in the tensor `input` that
-   *  are selected by the slice parameters. The slice parameters `begin` `end`
-   *  `strides` etc. work exactly as in `StridedSlice`.
+   *  within a given variable according to `indices`.
    *  <p>
-   *  NOTE this op currently does not support broadcasting and so `value`'s shape
-   *  must be exactly the shape produced by the slice of `input`.
+   *  `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
+   *  <p>
+   *  `indices` must be integer tensor, containing indices into `ref`.
+   *  It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
+   *  <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`.
+   *  <p>
+   *  `updates` is `Tensor` of rank `Q-1+P-K` with shape:
+   *  <pre>{@code
+   *  [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]]
+   *  }</pre>
+   *  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:
+   *  <pre>{@code
+   *  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)
+   *  }</pre>
+   *  The resulting update to ref would look like this:
+   *  <p>
+   *      [1, -9, 3, -6, -4, 6, 7, -4]
+   *  <p>
+   *  See `tf.scatter_nd` for more details about how to make updates to
+   *  slices.
    *
-   * @param <T> data type for {@code output()} output
-   * @param input
-   * @param begin
-   * @param end
-   * @param strides
-   * @param value
+   * @param <T> data type for {@code outputRef()} output
+   * @param ref A mutable Tensor. Should be from a Variable node.
+   * @param indices A Tensor. Must be one of the following types: int32, int64.
+   *  A tensor of indices into ref.
+   * @param updates A Tensor. Must have the same type as ref. A tensor of updated values
+   *  to subtract from ref.
    * @param options carries optional attributes values
-   * @return a new instance of TensorStridedSliceUpdate
+   * @return a new instance of ScatterNdSub
    */
-  public <T extends TType, U extends TNumber> TensorStridedSliceUpdate<T> tensorStridedSliceUpdate(
-      Operand<T> input, Operand<U> begin, Operand<U> end, Operand<U> strides, Operand<T> value,
-      TensorStridedSliceUpdate.Options... options) {
-    return TensorStridedSliceUpdate.create(scope, input, begin, end, strides, value, options);
+  public <T extends TType, U extends TNumber> ScatterNdSub<T> scatterNdSub(Operand<T> ref,
+      Operand<U> indices, Operand<T> updates, ScatterNdSub.Options... options) {
+    return ScatterNdSub.create(scope, ref, indices, updates, options);
   }
 
   /**
-   * Constructs a tensor by tiling a given tensor.
+   * Applies sparse `updates` to individual values or slices within a given
    *  <p>
-   *  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]`.
+   *  variable according to `indices`.
    *  <p>
-   *  >>> a = tf.constant([[1,2,3],[4,5,6]], tf.int32)
-   *  >>> b = tf.constant([1,2], tf.int32)
-   *  >>> tf.tile(a, b)
-   *  <tf.Tensor: shape=(2, 6), dtype=int32, numpy=
-   *  array([[1, 2, 3, 1, 2, 3],
-   *         [4, 5, 6, 4, 5, 6]], dtype=int32)>
-   *  >>> c = tf.constant([2,1], tf.int32)
-   *  >>> tf.tile(a, c)
-   *  <tf.Tensor: shape=(4, 3), dtype=int32, numpy=
-   *  array([[1, 2, 3],
-   *         [4, 5, 6],
-   *         [1, 2, 3],
-   *         [4, 5, 6]], dtype=int32)>
-   *  >>> d = tf.constant([2,2], tf.int32)
-   *  >>> tf.tile(a, d)
-   *  <tf.Tensor: shape=(4, 6), dtype=int32, numpy=
-   *  array([[1, 2, 3, 1, 2, 3],
-   *         [4, 5, 6, 4, 5, 6],
-   *         [1, 2, 3, 1, 2, 3],
-   *         [4, 5, 6, 4, 5, 6]], dtype=int32)>
-   *
-   * @param <T> data type for {@code output()} output
-   * @param input 1-D or higher.
-   * @param multiples 1-D. Length must be the same as the number of dimensions in `input`
-   * @return a new instance of Tile
-   */
-  public <T extends TType, U extends TNumber> Tile<T> tile(Operand<T> input, Operand<U> multiples) {
-    return Tile.create(scope, input, multiples);
-  }
-
-  /**
-   * Provides the time since epoch in seconds.
+   *  `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
    *  <p>
-   *  Returns the timestamp as a `float64` for seconds since the Unix epoch.
+   *  `indices` must be integer tensor, containing indices into `ref`.
+   *  It must be shape \\([d_0, ..., d_{Q-2}, K]\\) where `0 < K <= P`.
    *  <p>
-   *  Note: the timestamp is computed when the op is executed, not when it is added
-   *  to the graph.
-   *
-   * @return a new instance of Timestamp
-   */
-  public Timestamp timestamp() {
-    return Timestamp.create(scope);
-  }
-
-  /**
-   * Perform batches of RPC requests.
+   *  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`.
    *  <p>
-   *  This op asynchronously performs either a single RPC request, or a batch
-   *  of requests.  RPC requests are defined by three main parameters:
+   *  `updates` is `Tensor` of rank `Q-1+P-K` with shape:
    *  <p>
-   *    - `address` (the host+port or BNS address of the request)
-   *    - `method` (the method name for the request)
-   *    - `request` (the serialized proto string, or vector of strings,
-   *       of the RPC request argument).
+   *  $$[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].$$
    *  <p>
-   *  For example, if you have an RPC service running on port localhost:2345,
-   *  and its interface is configured with the following proto declaration:
-   *  <pre>{@code
-   *  service MyService {
-   *    rpc MyMethod(MyRequestProto) returns (MyResponseProto) {
-   *    }
-   *  };
-   *  }</pre>
-   *  then call this op with arguments:
+   *  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:
    *  <pre>{@code
-   *  address = "localhost:2345"
-   *  method = "MyService/MyMethod"
+   *      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)
    *  }</pre>
-   *  The `request` tensor is a string tensor representing serialized `MyRequestProto`
-   *  strings; and the output string tensor `response` will have the same shape
-   *  and contain (upon successful completion) corresponding serialized
-   *  `MyResponseProto` strings.
-   *  <p>
-   *  For example, to send a single, empty, `MyRequestProto`, call
-   *  this op with `request = ""`.  To send 5 <b>parallel</b> empty requests,
-   *  call this op with `request = ["", "", "", "", ""]`.
+   *  The resulting update to ref would look like this:
    *  <p>
-   *  More generally, one can create a batch of `MyRequestProto` serialized protos
-   *  from regular batched tensors using the `encode_proto` op, and convert
-   *  the response `MyResponseProto` serialized protos to batched tensors
-   *  using the `decode_proto` op.
+   *      [1, 11, 3, 10, 9, 6, 7, 12]
    *  <p>
-   *  <b>NOTE</b> Working with serialized proto strings is faster than instantiating
-   *  actual proto objects in memory, so no performance degradation is expected
-   *  compared to writing custom kernels for this workflow.
+   *  See `tf.scatter_nd` for more details about how to make updates to
+   *  slices.
    *  <p>
-   *  Unlike the standard `Rpc` op, if the connection fails or the remote worker
-   *  returns an error status, this op does <b>not</b> reraise the exception.
-   *  Instead, the `status_code` and `status_message` entry for the corresponding RPC
-   *  call is set with the error returned from the RPC call.  The `response` tensor
-   *  will contain valid response values for those minibatch entries whose RPCs did
-   *  not fail; the rest of the entries will have empty strings.
+   *  See also `tf.scatter_update` and `tf.batch_scatter_update`.
    *
-   * @param address `0-D` or `1-D`.  The address (i.e. host_name:port) of the RPC server.
-   *  If this tensor has more than 1 element, then multiple parallel rpc requests
-   *  are sent.  This argument broadcasts with `method` and `request`.
-   * @param method `0-D` or `1-D`.  The method address on the RPC server.
-   *  If this tensor has more than 1 element, then multiple parallel rpc requests
-   *  are sent.  This argument broadcasts with `address` and `request`.
-   * @param request `0-D` or `1-D`.  Serialized proto strings: the rpc request argument.
-   *  If this tensor has more than 1 element, then multiple parallel rpc requests
-   *  are sent.  This argument broadcasts with `address` and `method`.
+   * @param <T> data type for {@code outputRef()} output
+   * @param ref A mutable Tensor. Should be from a Variable node.
+   * @param indices A Tensor. Must be one of the following types: int32, int64.
+   *  A tensor of indices into ref.
+   * @param updates A Tensor. Must have the same type as ref. A tensor of updated
+   *  values to add to ref.
    * @param options carries optional attributes values
-   * @return a new instance of TryRpc
+   * @return a new instance of ScatterNdUpdate
    */
-  public TryRpc tryRpc(Operand<TString> address, Operand<TString> method, Operand<TString> request,
-      TryRpc.Options... options) {
-    return TryRpc.create(scope, address, method, request, options);
+  public <T extends TType, U extends TNumber> ScatterNdUpdate<T> scatterNdUpdate(Operand<T> ref,
+      Operand<U> indices, Operand<T> updates, ScatterNdUpdate.Options... options) {
+    return ScatterNdUpdate.create(scope, ref, indices, updates, options);
   }
 
   /**
-   * Reverses the operation of Batch for a single output Tensor.
+   * Subtracts sparse updates to a variable reference.
    *  <p>
-   *  An instance of Unbatch either receives an empty batched_tensor, in which case it
-   *  asynchronously waits until the values become available from a concurrently
-   *  running instance of Unbatch with the same container and shared_name, or receives
-   *  a non-empty batched_tensor in which case it finalizes all other concurrently
-   *  running instances and outputs its own element from the batch.
+   *  <pre>{@code
+   *      # 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, ...]
+   *  }</pre>
+   *  This operation outputs `ref` after the update is done.
+   *  This makes it easier to chain operations that need to use the reset value.
    *  <p>
-   *  batched_tensor: The possibly transformed output of Batch. The size of the first
-   *   dimension should remain unchanged by the transformations for the operation to
-   *   work.
-   *  batch_index: The matching batch_index obtained from Batch.
-   *  id: The id scalar emitted by Batch.
-   *  unbatched_tensor: The Tensor corresponding to this execution.
-   *  timeout_micros: Maximum amount of time (in microseconds) to wait to receive the
-   *   batched input tensor associated with a given invocation of the op.
-   *  container: Container to control resource sharing.
-   *  shared_name: Instances of Unbatch with the same container and shared_name are
-   *   assumed to possibly belong to the same batch. If left empty, the op name will
-   *   be used as the shared name.
+   *  Duplicate entries are handled correctly: if multiple `indices` reference
+   *  the same location, their (negated) contributions add.
+   *  <p>
+   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+   *  <p>
+   *  <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>
    *
-   * @param <T> data type for {@code unbatchedTensor()} output
-   * @param batchedTensor
-   * @param batchIndex
-   * @param id
-   * @param timeoutMicros
+   * @param <T> data type for {@code outputRef()} output
+   * @param ref Should be from a `Variable` node.
+   * @param indices A tensor of indices into the first dimension of `ref`.
+   * @param updates A tensor of updated values to subtract from `ref`.
    * @param options carries optional attributes values
-   * @return a new instance of Unbatch
+   * @return a new instance of ScatterSub
    */
-  public <T extends TType> Unbatch<T> unbatch(Operand<T> batchedTensor, Operand<TInt64> batchIndex,
-      Operand<TInt64> id, Long timeoutMicros, Unbatch.Options... options) {
-    return Unbatch.create(scope, batchedTensor, batchIndex, id, timeoutMicros, options);
+  public <T extends TType, U extends TNumber> ScatterSub<T> scatterSub(Operand<T> ref,
+      Operand<U> indices, Operand<T> updates, ScatterSub.Options... options) {
+    return ScatterSub.create(scope, ref, indices, updates, options);
   }
 
   /**
-   * Gradient of Unbatch.
+   * Applies sparse updates to a variable reference.
    *  <p>
-   *  Acts like Batch but using the given batch_index index of batching things as they
-   *  become available. This ensures that the gradients are propagated back in the
-   *  same session which did the forward pass.
+   *  This operation computes
+   *  <pre>{@code
+   *      # 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, ...]
+   *  }</pre>
+   *  This operation outputs `ref` after the update is done.
+   *  This makes it easier to chain operations that need to use the reset value.
    *  <p>
-   *  original_input: The input to the Unbatch operation this is the gradient of.
-   *  batch_index: The batch_index given to the Unbatch operation this is the gradient
-   *  of.
-   *  grad: The downstream gradient.
-   *  id: The id scalar emitted by Batch.
-   *  batched_grad: The return value, either an empty tensor or the batched gradient.
-   *  container: Container to control resource sharing.
-   *  shared_name: Instances of UnbatchGrad with the same container and shared_name
-   *   are assumed to possibly belong to the same batch. If left empty, the op name
-   *   will be used as the shared name.
+   *  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.
+   *  <p>
+   *  Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+   *  <p>
+   *  <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>
+   *  <p>
+   *  See also `tf.batch_scatter_update` and `tf.scatter_nd_update`.
    *
-   * @param <T> data type for {@code batchedGrad()} output
-   * @param originalInput
-   * @param batchIndex
-   * @param grad
-   * @param id
+   * @param <T> data type for {@code outputRef()} output
+   * @param ref Should be from a `Variable` node.
+   * @param indices A tensor of indices into the first dimension of `ref`.
+   * @param updates A tensor of updated values to store in `ref`.
    * @param options carries optional attributes values
-   * @return a new instance of UnbatchGrad
+   * @return a new instance of ScatterUpdate
    */
-  public <T extends TType> UnbatchGrad<T> unbatchGrad(Operand<T> originalInput,
-      Operand<TInt64> batchIndex, Operand<T> grad, Operand<TInt64> id,
-      UnbatchGrad.Options... options) {
-    return UnbatchGrad.create(scope, originalInput, batchIndex, grad, id, options);
+  public <T extends TType, U extends TNumber> ScatterUpdate<T> scatterUpdate(Operand<T> ref,
+      Operand<U> indices, Operand<T> updates, ScatterUpdate.Options... options) {
+    return ScatterUpdate.create(scope, ref, indices, updates, options);
   }
 
   /**
-   * Finds unique elements along an axis of a tensor.
-   *  <p>
-   *  This operation either returns a tensor `y` containing unique elements
-   *  along the `axis` of a tensor. The returned unique elements is sorted
-   *  in the same order as they occur along `axis` in `x`.
-   *  This operation also returns a tensor `idx` that is the same size as
-   *  the number of the elements in `x` along the `axis` dimension. It
-   *  contains the index in the unique output `y`.
-   *  In other words, for an `1-D` tensor `x` with `axis = None:
-   *  <p>
-   *  `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
-   *  <p>
-   *  For example:
-   *  <pre>{@code
-   *  # 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]
-   *  }</pre>
-   *  For an `2-D` tensor `x` with `axis = 0`:
-   *  <pre>{@code
-   *  # tensor 'x' is [[1, 0, 0],
-   *  #                [1, 0, 0],
-   *  #                [2, 0, 0]]
-   *  y, idx = unique(x, axis=0)
-   *  y ==> [[1, 0, 0],
-   *         [2, 0, 0]]
-   *  idx ==> [0, 0, 1]
-   *  }</pre>
-   *  For an `2-D` tensor `x` with `axis = 1`:
-   *  <pre>{@code
-   *  # tensor 'x' is [[1, 0, 0],
-   *  #                [1, 0, 0],
-   *  #                [2, 0, 0]]
-   *  y, idx = unique(x, axis=1)
-   *  y ==> [[1, 0],
-   *         [1, 0],
-   *         [2, 0]]
-   *  idx ==> [0, 1, 1]
-   *  }</pre>
    *
-   * @param <T> data type for {@code y()} output
-   * @param <V> data type for {@code idx()} output
-   * @param x A `Tensor`.
-   * @param axis A `Tensor` of type `int32` (default: None). The axis of the Tensor to
-   *  find the unique elements.
-   * @return a new instance of Unique
+   * @param <T> data type for {@code output()} output
+   * @param condition
+   * @param t
+   * @param e
+   * @return a new instance of Select
    */
-  public <T extends TType, U extends TNumber> Unique<T, TInt32> unique(Operand<T> x,
-      Operand<U> axis) {
-    return Unique.create(scope, x, axis);
+  public <T extends TType> Select<T> select(Operand<TBool> condition, Operand<T> t, Operand<T> e) {
+    return Select.create(scope, condition, t, e);
   }
 
   /**
-   * Finds unique elements along an axis of a tensor.
+   * Computes the difference between two lists of numbers or strings.
    *  <p>
-   *  This operation either returns a tensor `y` containing unique elements
-   *  along the `axis` of a tensor. The returned unique elements is sorted
-   *  in the same order as they occur along `axis` in `x`.
-   *  This operation also returns a tensor `idx` that is the same size as
-   *  the number of the elements in `x` along the `axis` dimension. It
-   *  contains the index in the unique output `y`.
-   *  In other words, for an `1-D` tensor `x` with `axis = None:
+   *  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:
    *  <p>
-   *  `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
+   *  `out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]`
    *  <p>
-   *  For example:
-   *  <pre>{@code
-   *  # 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]
-   *  }</pre>
-   *  For an `2-D` tensor `x` with `axis = 0`:
+   *  For example, given this input:
    *  <pre>{@code
-   *  # tensor 'x' is [[1, 0, 0],
-   *  #                [1, 0, 0],
-   *  #                [2, 0, 0]]
-   *  y, idx = unique(x, axis=0)
-   *  y ==> [[1, 0, 0],
-   *         [2, 0, 0]]
-   *  idx ==> [0, 0, 1]
+   *  x = [1, 2, 3, 4, 5, 6]
+   *  y = [1, 3, 5]
    *  }</pre>
-   *  For an `2-D` tensor `x` with `axis = 1`:
+   *  This operation would return:
    *  <pre>{@code
-   *  # tensor 'x' is [[1, 0, 0],
-   *  #                [1, 0, 0],
-   *  #                [2, 0, 0]]
-   *  y, idx = unique(x, axis=1)
-   *  y ==> [[1, 0],
-   *         [1, 0],
-   *         [2, 0]]
-   *  idx ==> [0, 1, 1]
+   *  out ==> [2, 4, 6]
+   *  idx ==> [1, 3, 5]
    *  }</pre>
    *
-   * @param <T> data type for {@code y()} output
-   * @param <V> data type for {@code idx()} output
-   * @param x A `Tensor`.
-   * @param axis A `Tensor` of type `int32` (default: None). The axis of the Tensor to
-   *  find the unique elements.
-   * @param outIdx
-   * @return a new instance of Unique
+   * @param <T> data type for {@code out()} output
+   * @param <U> data type for {@code idx()} output
+   * @param x 1-D. Values to keep.
+   * @param y 1-D. Values to remove.
+   * @return a new instance of SetDiff1d
    */
-  public <T extends TType, V extends TNumber, U extends TNumber> Unique<T, V> unique(Operand<T> x,
-      Operand<U> axis, DataType<V> outIdx) {
-    return Unique.create(scope, x, axis, outIdx);
+  public <T extends TType> SetDiff1d<T, TInt32> setDiff1d(Operand<T> x, Operand<T> y) {
+    return SetDiff1d.create(scope, x, y);
   }
 
   /**
-   * Finds unique elements along an axis of a tensor.
+   * Computes the difference between two lists of numbers or strings.
    *  <p>
-   *  This operation either returns a tensor `y` containing unique elements
-   *  along the `axis` of a tensor. The returned unique elements is sorted
-   *  in the same order as they occur along `axis` in `x`.
-   *  This operation also returns a tensor `idx` and a tensor `count`
-   *  that are the same size as the number of the elements in `x` along the
-   *  `axis` dimension. The `idx` contains the index in the unique output `y`
-   *  and the `count` contains the count in the unique output `y`.
-   *  In other words, for an `1-D` tensor `x` with `axis = None:
+   *  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:
    *  <p>
-   *  `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
+   *  `out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]`
    *  <p>
-   *  For example:
-   *  <pre>{@code
-   *  # 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]
-   *  }</pre>
-   *  For an `2-D` tensor `x` with `axis = 0`:
+   *  For example, given this input:
    *  <pre>{@code
-   *  # tensor 'x' is [[1, 0, 0],
-   *  #                [1, 0, 0],
-   *  #                [2, 0, 0]]
-   *  y, idx, count = unique_with_counts(x, axis=0)
-   *  y ==> [[1, 0, 0],
-   *         [2, 0, 0]]
-   *  idx ==> [0, 0, 1]
-   *  count ==> [2, 1]
+   *  x = [1, 2, 3, 4, 5, 6]
+   *  y = [1, 3, 5]
    *  }</pre>
-   *  For an `2-D` tensor `x` with `axis = 1`:
+   *  This operation would return:
    *  <pre>{@code
-   *  # tensor 'x' is [[1, 0, 0],
-   *  #                [1, 0, 0],
-   *  #                [2, 0, 0]]
-   *  y, idx, count = unique_with_counts(x, axis=1)
-   *  y ==> [[1, 0],
-   *         [1, 0],
-   *         [2, 0]]
-   *  idx ==> [0, 1, 1]
-   *  count ==> [1, 2]
+   *  out ==> [2, 4, 6]
+   *  idx ==> [1, 3, 5]
    *  }</pre>
    *
-   * @param <T> data type for {@code y()} output
-   * @param <V> data type for {@code idx()} output
-   * @param x A `Tensor`.
-   * @param axis A `Tensor` of type `int32` (default: None). The axis of the Tensor to
-   *  find the unique elements.
-   * @return a new instance of UniqueWithCounts
+   * @param <T> data type for {@code out()} output
+   * @param <U> data type for {@code idx()} output
+   * @param x 1-D. Values to keep.
+   * @param y 1-D. Values to remove.
+   * @param outIdx
+   * @return a new instance of SetDiff1d
    */
-  public <T extends TType, U extends TNumber> UniqueWithCounts<T, TInt32> uniqueWithCounts(
-      Operand<T> x, Operand<U> axis) {
-    return UniqueWithCounts.create(scope, x, axis);
+  public <T extends TType, U extends TNumber> SetDiff1d<T, U> setDiff1d(Operand<T> x, Operand<T> y,
+      DataType<U> outIdx) {
+    return SetDiff1d.create(scope, x, y, outIdx);
   }
 
   /**
-   * Finds unique elements along an axis of a tensor.
+   * Number of unique elements along last dimension of input `set`.
    *  <p>
-   *  This operation either returns a tensor `y` containing unique elements
-   *  along the `axis` of a tensor. The returned unique elements is sorted
-   *  in the same order as they occur along `axis` in `x`.
-   *  This operation also returns a tensor `idx` and a tensor `count`
-   *  that are the same size as the number of the elements in `x` along the
-   *  `axis` dimension. The `idx` contains the index in the unique output `y`
-   *  and the `count` contains the count in the unique output `y`.
-   *  In other words, for an `1-D` tensor `x` with `axis = None:
+   *  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.
    *  <p>
-   *  `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
+   *  If `validate_indices` is `True`, this op validates the order and range of `set`
+   *  indices.
+   *
+   * @param setIndices 2D `Tensor`, indices of a `SparseTensor`.
+   * @param setValues 1D `Tensor`, values of a `SparseTensor`.
+   * @param setShape 1D `Tensor`, shape of a `SparseTensor`.
+   * @param options carries optional attributes values
+   * @return a new instance of SetSize
+   */
+  public <T extends TType> SetSize setSize(Operand<TInt64> setIndices, Operand<T> setValues,
+      Operand<TInt64> setShape, SetSize.Options... options) {
+    return SetSize.create(scope, setIndices, setValues, setShape, options);
+  }
+
+  /**
+   * Returns the shape of a tensor.
+   *  <p>
+   *  This operation returns a 1-D integer tensor representing the shape of `input`.
    *  <p>
    *  For example:
    *  <pre>{@code
-   *  # 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]
-   *  }</pre>
-   *  For an `2-D` tensor `x` with `axis = 0`:
-   *  <pre>{@code
-   *  # tensor 'x' is [[1, 0, 0],
-   *  #                [1, 0, 0],
-   *  #                [2, 0, 0]]
-   *  y, idx, count = unique_with_counts(x, axis=0)
-   *  y ==> [[1, 0, 0],
-   *         [2, 0, 0]]
-   *  idx ==> [0, 0, 1]
-   *  count ==> [2, 1]
-   *  }</pre>
-   *  For an `2-D` tensor `x` with `axis = 1`:
-   *  <pre>{@code
-   *  # tensor 'x' is [[1, 0, 0],
-   *  #                [1, 0, 0],
-   *  #                [2, 0, 0]]
-   *  y, idx, count = unique_with_counts(x, axis=1)
-   *  y ==> [[1, 0],
-   *         [1, 0],
-   *         [2, 0]]
-   *  idx ==> [0, 1, 1]
-   *  count ==> [1, 2]
+   *  # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
+   *  shape(t) ==> [2, 2, 3]
    *  }</pre>
    *
-   * @param <T> data type for {@code y()} output
-   * @param <V> data type for {@code idx()} output
-   * @param x A `Tensor`.
-   * @param axis A `Tensor` of type `int32` (default: None). The axis of the Tensor to
-   *  find the unique elements.
-   * @param outIdx
-   * @return a new instance of UniqueWithCounts
+   * @param <U> data type for {@code output()} output
+   * @param input
+   * @return a new instance of Shape
    */
-  public <T extends TType, V extends TNumber, U extends TNumber> UniqueWithCounts<T, V> uniqueWithCounts(
-      Operand<T> x, Operand<U> axis, DataType<V> outIdx) {
-    return UniqueWithCounts.create(scope, x, axis, outIdx);
+  public <T extends TType> org.tensorflow.op.core.Shape<TInt32> shape(Operand<T> input) {
+    return org.tensorflow.op.core.Shape.create(scope, input);
   }
 
   /**
-   * Converts an array of flat indices into a tuple of coordinate arrays.
+   * Returns the shape of a tensor.
    *  <p>
-   *
-   *  Example:
+   *  This operation returns a 1-D integer tensor representing the shape of `input`.
+   *  <p>
+   *  For example:
    *  <pre>{@code
-   *  y = tf.unravel_index(indices=[2, 5, 7], dims=[3, 3])
-   *  # 'dims' represent a hypothetical (3, 3) tensor of indices:
-   *  # [[0, 1, *2*],
-   *  #  [3, 4, *5*],
-   *  #  [6, *7*, 8]]
-   *  # For each entry from 'indices', this operation returns
-   *  # its coordinates (marked with '*'), such as
-   *  # 2 ==> (0, 2)
-   *  # 5 ==> (1, 2)
-   *  # 7 ==> (2, 1)
-   *  y ==> [[0, 1, 2], [2, 2, 1]]
+   *  # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
+   *  shape(t) ==> [2, 2, 3]
    *  }</pre>
    *
-   * @compatibility(numpy) Equivalent to np.unravel_index
-   * @end_compatibility
-   * @param <T> data type for {@code output()} output
-   * @param indices An 0-D or 1-D `int` Tensor whose elements are indices into the
-   *  flattened version of an array of dimensions dims.
-   * @param dims An 1-D `int` Tensor. The shape of the array to use for unraveling
-   *  indices.
-   * @return a new instance of UnravelIndex
+   * @param <U> data type for {@code output()} output
+   * @param input
+   * @param outType
+   * @return a new instance of Shape
    */
-  public <T extends TNumber> UnravelIndex<T> unravelIndex(Operand<T> indices, Operand<T> dims) {
-    return UnravelIndex.create(scope, indices, dims);
+  public <U extends TNumber, T extends TType> org.tensorflow.op.core.Shape<U> shape(
+      Operand<T> input, DataType<U> outType) {
+    return org.tensorflow.op.core.Shape.create(scope, input, outType);
   }
 
   /**
-   * Unpacks a given dimension of a rank-`R` tensor into `num` rank-`(R-1)` tensors.
-   *  <p>
-   *  Unpacks `num` tensors from `value` by chipping it along the `axis` dimension.
-   *  For example, given a tensor of shape `(A, B, C, D)`;
-   *  <p>
-   *  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`).
-   *  <p>
-   *  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.
+   * Returns shape of tensors.
    *  <p>
-   *  This is the opposite of `pack`.
+   *  This operation returns N 1-D integer tensors representing shape of `input[i]s`.
    *
-   * @param <T> data type for {@code output()} output
-   * @param value 1-D or higher, with `axis` dimension size equal to `num`.
-   * @param num
-   * @param options carries optional attributes values
-   * @return a new instance of Unstack
+   * @param <U> data type for {@code output()} output
+   * @param input
+   * @return a new instance of ShapeN
    */
-  public <T extends TType> Unstack<T> unstack(Operand<T> value, Long num,
-      Unstack.Options... options) {
-    return Unstack.create(scope, value, num, options);
+  public <T extends TType> ShapeN<TInt32> shapeN(Iterable<Operand<T>> input) {
+    return ShapeN.create(scope, input);
   }
 
   /**
-   * Op is similar to a lightweight Dequeue.
+   * Returns shape of tensors.
    *  <p>
-   *  The basic functionality is similar to dequeue with many fewer
-   *  capabilities and options.  This Op is optimized for performance.
-   *
-   * @param dtypes
-   * @param options carries optional attributes values
-   * @return a new instance of Unstage
-   */
-  public Unstage unstage(List<DataType<?>> dtypes, Unstage.Options... options) {
-    return Unstage.create(scope, dtypes, options);
-  }
-
-  /**
-   * Creates a rank-1 constant of {@code long} elements.
-   *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a long constant
-   */
-  public Constant<TInt64> val(long[] data) {
-    return Constant.vectorOf(scope, data);
-  }
-
-  /**
-   * Creates a rank-6 constant of {@code double} elements.
-   *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a double constant
-   */
-  public Constant<TFloat64> val(double[][][][][][] data) {
-    return Constant.tensorOf(scope, data);
-  }
-
-  /**
-   * Creates a constant of {@code byte} elements that is a copy of a given n-dimensional array.
-   *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data an n-dimensional array of {@code byte} elements.
-   * @return a byte constant
-   */
-  public Constant<TUint8> val(ByteNdArray data) {
-    return Constant.tensorOf(scope, data);
-  }
-
-  /**
-   * Creates a rank-4 constant of {@code boolean} elements.
-   *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a boolean constant
-   */
-  public Constant<TBool> val(boolean[][][][] data) {
-    return Constant.tensorOf(scope, data);
-  }
-
-  /**
-   * Creates a constant of {@code float} elements that is a copy of a given n-dimensional array.
-   *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data an n-dimensional array of {@code float} elements.
-   * @return a float constant
-   */
-  public Constant<TFloat32> val(FloatNdArray data) {
-    return Constant.tensorOf(scope, data);
-  }
-
-  /**
-   * Creates a rank-6 constant of {@code boolean} elements.
-   *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a boolean constant
-   */
-  public Constant<TBool> val(boolean[][][][][][] data) {
-    return Constant.tensorOf(scope, data);
-  }
-
-  /**
-   * Creates a rank-2 constant of {@code long} elements.
+   *  This operation returns N 1-D integer tensors representing shape of `input[i]s`.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a long constant
+   * @param <U> data type for {@code output()} output
+   * @param input
+   * @param outType
+   * @return a new instance of ShapeN
    */
-  public Constant<TInt64> val(long[][] data) {
-    return Constant.tensorOf(scope, data);
+  public <U extends TNumber, T extends TType> ShapeN<U> shapeN(Iterable<Operand<T>> input,
+      DataType<U> outType) {
+    return ShapeN.create(scope, input, outType);
   }
 
   /**
-   * Creates a constant of {@code double} elements that is a copy of a given n-dimensional array.
+   * Returns the size of a tensor.
+   *  <p>
+   *  This operation returns an integer representing the number of elements in
+   *  `input`.
+   *  <p>
+   *  For example:
+   *  <pre>{@code
+   *  # 't' is [[[1, 1,, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]]
+   *  size(t) ==> 12
+   *  }</pre>
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data an n-dimensional array of {@code double} elements.
-   * @return a double constant
+   * @param <U> data type for {@code output()} output
+   * @param input
+   * @return a new instance of Size
    */
-  public Constant<TFloat64> val(DoubleNdArray data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType> Size<TInt32> size(Operand<T> input) {
+    return Size.create(scope, input);
   }
 
   /**
-   * Creates a rank-3 constant of {@code boolean} elements.
+   * Returns the size of a tensor.
+   *  <p>
+   *  This operation returns an integer representing the number of elements in
+   *  `input`.
+   *  <p>
+   *  For example:
+   *  <pre>{@code
+   *  # 't' is [[[1, 1,, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]]
+   *  size(t) ==> 12
+   *  }</pre>
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a boolean constant
+   * @param <U> data type for {@code output()} output
+   * @param input
+   * @param outType
+   * @return a new instance of Size
    */
-  public Constant<TBool> val(boolean[][][] data) {
-    return Constant.tensorOf(scope, data);
+  public <U extends TNumber, T extends TType> Size<U> size(Operand<T> input, DataType<U> outType) {
+    return Size.create(scope, input, outType);
   }
 
   /**
-   * Creates a constant containing a single {@code float} element.
+   * Parses a text file and creates a batch of examples.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data The value to put into the new constant.
-   * @return a float constant
+   * @param filename The corpus's text file name.
+   * @param batchSize The size of produced batch.
+   * @param options carries optional attributes values
+   * @return a new instance of Skipgram
    */
-  public Constant<TFloat32> val(float data) {
-    return Constant.scalarOf(scope, data);
+  public Skipgram skipgram(String filename, Long batchSize, Skipgram.Options... options) {
+    return Skipgram.create(scope, filename, batchSize, options);
   }
 
   /**
-   * Creates a rank-6 constant of {@code float} elements.
+   * Return a slice from 'input'.
+   *  <p>
+   *  The output tensor is a tensor with dimensions described by 'size'
+   *  whose values are extracted from 'input' starting at the offsets in
+   *  'begin'.
+   *  <p>
+   *  <i>Requirements</i>:
+   *    0 <= begin[i] <= begin[i] + size[i] <= Di  for i in [0, n)
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a float constant
+   * @param <T> data type for {@code output()} output
+   * @param input
+   * @param begin begin[i] specifies the offset into the 'i'th dimension of
+   *  'input' to slice from.
+   * @param size 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]).
+   * @return a new instance of Slice
    */
-  public Constant<TFloat32> val(float[][][][][][] data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType, U extends TNumber> Slice<T> slice(Operand<T> input, Operand<U> begin,
+      Operand<U> size) {
+    return Slice.create(scope, input, begin, size);
   }
 
   /**
-   * Creates a rank-5 constant of {@code byte} elements.
+   * Returns a copy of the input tensor.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a byte constant
+   * @param <T> data type for {@code output()} output
+   * @param input
+   * @return a new instance of Snapshot
    */
-  public Constant<TUint8> val(byte[][][][][] data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType> Snapshot<T> snapshot(Operand<T> input) {
+    return Snapshot.create(scope, input);
   }
 
   /**
-   * Creates a rank-4 constant of {@code float} elements.
+   * SpaceToBatch for N-D tensors of type T.
+   *  <p>
+   *  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.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a float constant
+   * @param <T> data type for {@code output()} output
+   * @param input N-D with shape `input_shape = [batch] + spatial_shape + remaining_shape`,
+   *  where spatial_shape has `M` dimensions.
+   * @param blockShape 1-D with shape `[M]`, all values must be >= 1.
+   * @param paddings 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`.
+   *  <p>
+   *  This operation is equivalent to the following steps:
+   *  <p>
+   *  1. Zero-pad the start and end of dimensions `[1, ..., M]` of the
+   *     input according to `paddings` to produce `padded` of shape `padded_shape`.
+   *  <p>
+   *  2. Reshape `padded` to `reshaped_padded` of shape:
+   *  <p>
+   *       [batch] +
+   *       [padded_shape[1] / block_shape[0],
+   *         block_shape[0],
+   *        ...,
+   *        padded_shape[M] / block_shape[M-1],
+   *        block_shape[M-1]] +
+   *       remaining_shape
+   *  <p>
+   *  3. Permute dimensions of `reshaped_padded` to produce
+   *     `permuted_reshaped_padded` of shape:
+   *  <p>
+   *       block_shape +
+   *       [batch] +
+   *       [padded_shape[1] / block_shape[0],
+   *        ...,
+   *        padded_shape[M] / block_shape[M-1]] +
+   *       remaining_shape
+   *  <p>
+   *  4. Reshape `permuted_reshaped_padded` to flatten `block_shape` into the batch
+   *     dimension, producing an output tensor of shape:
+   *  <p>
+   *       [batch * prod(block_shape)] +
+   *       [padded_shape[1] / block_shape[0],
+   *        ...,
+   *        padded_shape[M] / block_shape[M-1]] +
+   *       remaining_shape
+   *  <p>
+   *  Some examples:
+   *  <p>
+   *  (1) For the following input of shape `[1, 2, 2, 1]`, `block_shape = [2, 2]`, and
+   *      `paddings = [[0, 0], [0, 0]]`:
+   *  <pre>{@code
+   *  x = [[[[1], [2]], [[3], [4]]]]
+   *  }</pre>
+   *  The output tensor has shape `[4, 1, 1, 1]` and value:
+   *  <pre>{@code
+   *  [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
+   *  }</pre>
+   *  (2) For the following input of shape `[1, 2, 2, 3]`, `block_shape = [2, 2]`, and
+   *      `paddings = [[0, 0], [0, 0]]`:
+   *  <pre>{@code
+   *  x = [[[[1, 2, 3], [4, 5, 6]],
+   *        [[7, 8, 9], [10, 11, 12]]]]
+   *  }</pre>
+   *  The output tensor has shape `[4, 1, 1, 3]` and value:
+   *  <pre>{@code
+   *  [[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
+   *  }</pre>
+   *  (3) For the following input of shape `[1, 4, 4, 1]`, `block_shape = [2, 2]`, and
+   *      `paddings = [[0, 0], [0, 0]]`:
+   *  <pre>{@code
+   *  x = [[[[1],   [2],  [3],  [4]],
+   *        [[5],   [6],  [7],  [8]],
+   *        [[9],  [10], [11],  [12]],
+   *        [[13], [14], [15],  [16]]]]
+   *  }</pre>
+   *  The output tensor has shape `[4, 2, 2, 1]` and value:
+   *  <pre>{@code
+   *  x = [[[[1], [3]], [[9], [11]]],
+   *       [[[2], [4]], [[10], [12]]],
+   *       [[[5], [7]], [[13], [15]]],
+   *       [[[6], [8]], [[14], [16]]]]
+   *  }</pre>
+   *  (4) For the following input of shape `[2, 2, 4, 1]`, block_shape = `[2, 2]`, and
+   *      paddings = `[[0, 0], [2, 0]]`:
+   *  <pre>{@code
+   *  x = [[[[1],   [2],  [3],  [4]],
+   *        [[5],   [6],  [7],  [8]]],
+   *       [[[9],  [10], [11],  [12]],
+   *        [[13], [14], [15],  [16]]]]
+   *  }</pre>
+   *  The output tensor has shape `[8, 1, 3, 1]` and value:
+   *  <pre>{@code
+   *  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]]]]
+   *  }</pre>
+   *  Among others, this operation is useful for reducing atrous convolution into
+   *  regular convolution.
+   * @return a new instance of SpaceToBatchNd
    */
-  public Constant<TFloat32> val(float[][][][] data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType, U extends TNumber, V extends TNumber> SpaceToBatchNd<T> spaceToBatchNd(
+      Operand<T> input, Operand<U> blockShape, Operand<V> paddings) {
+    return SpaceToBatchNd.create(scope, input, blockShape, paddings);
   }
 
   /**
-   * Creates a rank-5 constant of {@code double} elements.
+   * Splits a tensor into `num_split` tensors along one dimension.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a double constant
+   * @param <T> data type for {@code output()} output
+   * @param axis 0-D.  The dimension along which to split.  Must be in the range
+   *  `[-rank(value), rank(value))`.
+   * @param value The tensor to split.
+   * @param numSplit The number of ways to split.  Must evenly divide
+   *  `value.shape[split_dim]`.
+   * @return a new instance of Split
    */
-  public Constant<TFloat64> val(double[][][][][] data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType> Split<T> split(Operand<TInt32> axis, Operand<T> value, Long numSplit) {
+    return Split.create(scope, axis, value, numSplit);
   }
 
   /**
-   * Creates a constant containing a single {@code int} element.
+   * Splits a tensor into `num_split` tensors along one dimension.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data The value to put into the new constant.
-   * @return an integer constant
+   * @param <T> data type for {@code output()} output
+   * @param value The tensor to split.
+   * @param sizeSplits 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.
+   * @param axis 0-D.  The dimension along which to split.  Must be in the range
+   *  `[-rank(value), rank(value))`.
+   * @param numSplit
+   * @return a new instance of SplitV
    */
-  public Constant<TInt32> val(int data) {
-    return Constant.scalarOf(scope, data);
+  public <T extends TType, U extends TNumber> SplitV<T> splitV(Operand<T> value,
+      Operand<U> sizeSplits, Operand<TInt32> axis, Long numSplit) {
+    return SplitV.create(scope, value, sizeSplits, axis, numSplit);
   }
 
   /**
-   * Creates a rank-3 constant of {@code float} elements.
+   * Removes dimensions of size 1 from the shape of a tensor.
+   *  <p>
+   *  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
+   *  `axis`.
+   *  <p>
+   *  For example:
+   *  <pre>{@code
+   *  # 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
+   *  shape(squeeze(t)) ==> [2, 3]
+   *  }</pre>
+   *  Or, to remove specific size 1 dimensions:
+   *  <pre>{@code
+   *  # 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
+   *  shape(squeeze(t, [2, 4])) ==> [1, 2, 3, 1]
+   *  }</pre>
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a float constant
+   * @param <T> data type for {@code output()} output
+   * @param input The `input` to squeeze.
+   * @param options carries optional attributes values
+   * @return a new instance of Squeeze
    */
-  public Constant<TFloat32> val(float[][][] data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType> Squeeze<T> squeeze(Operand<T> input, Squeeze.Options... options) {
+    return Squeeze.create(scope, input, options);
   }
 
   /**
-   * Creates a rank-1 constant of {@code byte} elements.
+   * Packs a list of `N` rank-`R` tensors into one rank-`(R+1)` tensor.
+   *  <p>
+   *  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)`;
+   *  <p>
+   *  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.
+   *  <p>
+   *  For example:
+   *  <pre>{@code
+   *  # '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]]
+   *  }</pre>
+   *  This is the opposite of `unpack`.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a byte constant
+   * @param <T> data type for {@code output()} output
+   * @param values Must be of same shape and type.
+   * @param options carries optional attributes values
+   * @return a new instance of Stack
    */
-  public Constant<TUint8> val(byte[] data) {
-    return Constant.vectorOf(scope, data);
+  public <T extends TType> Stack<T> stack(Iterable<Operand<T>> values, Stack.Options... options) {
+    return Stack.create(scope, values, options);
   }
 
   /**
-   * Creates a rank-4 constant of {@code double} elements.
+   * Stage values similar to a lightweight Enqueue.
+   *  <p>
+   *  The basic functionality of this Op is similar to a queue with many
+   *  fewer capabilities and options.  This Op is optimized for performance.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a double constant
+   * @param values a list of tensors
+   *  dtypes A list of data types that inserted values should adhere to.
+   * @param options carries optional attributes values
+   * @return a new instance of Stage
    */
-  public Constant<TFloat64> val(double[][][][] data) {
-    return Constant.tensorOf(scope, data);
+  public Stage stage(Iterable<Operand<?>> values, Stage.Options... options) {
+    return Stage.create(scope, values, options);
   }
 
   /**
-   * Creates a constant of {@code boolean} elements that is a copy of a given n-dimensional array.
+   * Op removes all elements in the underlying container.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data an n-dimensional array of {@code boolean} elements.
-   * @return a boolean constant
+   * @param dtypes
+   * @param options carries optional attributes values
+   * @return a new instance of StageClear
    */
-  public Constant<TBool> val(BooleanNdArray data) {
-    return Constant.tensorOf(scope, data);
+  public StageClear stageClear(List<DataType<?>> dtypes, StageClear.Options... options) {
+    return StageClear.create(scope, dtypes, options);
   }
 
   /**
-   * Creates a rank-5 constant of {@code boolean} elements.
+   * Op peeks at the values at the specified index.  If the
+   *  <p>
+   *  underlying container does not contain sufficient elements
+   *  this op will block until it does.   This Op is optimized for
+   *  performance.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a boolean constant
+   * @param index
+   * @param dtypes
+   * @param options carries optional attributes values
+   * @return a new instance of StagePeek
    */
-  public Constant<TBool> val(boolean[][][][][] data) {
-    return Constant.tensorOf(scope, data);
+  public StagePeek stagePeek(Operand<TInt32> index, List<DataType<?>> dtypes,
+      StagePeek.Options... options) {
+    return StagePeek.create(scope, index, dtypes, options);
   }
 
   /**
-   * Creates a rank-3 constant of {@code int} elements.
+   * Op returns the number of elements in the underlying container.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return an integer constant
+   * @param dtypes
+   * @param options carries optional attributes values
+   * @return a new instance of StageSize
    */
-  public Constant<TInt32> val(int[][][] data) {
-    return Constant.tensorOf(scope, data);
+  public StageSize stageSize(List<DataType<?>> dtypes, StageSize.Options... options) {
+    return StageSize.create(scope, dtypes, options);
   }
 
   /**
-   * Creates a {@code String} constant using the default, UTF-8 encoding.
-   *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data The string to put into the new constant.
-   * @return a string constant
-   */
-  public Constant<TString> val(String data) {
-    return Constant.scalarOf(scope, data);
-  }
-
-  /**
-   * Creates a constant containing a single {@code double} element.
+   * Stops gradient computation.
+   *  <p>
+   *  When executed in a graph, this op outputs its input tensor as-is.
+   *  <p>
+   *  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.
+   *  <p>
+   *  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:
+   *  <ul>
+   *  <li>
+   *  The <i>EM</i> algorithm where the <i>M-step</i> should not involve backpropagation
+   *     through the output of the <i>E-step</i>.
+   *  </li>
+   *  <li>
+   *  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.
+   *  </li>
+   *  <li>
+   *  Adversarial training, where no backprop should happen through the adversarial
+   *     example generation process.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data The value to put into the new constant.
-   * @return a double constant
+   * @param <T> data type for {@code output()} output
+   * @param input
+   * @return a new instance of StopGradient
    */
-  public Constant<TFloat64> val(double data) {
-    return Constant.scalarOf(scope, data);
+  public <T extends TType> StopGradient<T> stopGradient(Operand<T> input) {
+    return StopGradient.create(scope, input);
   }
 
   /**
-   * Creates a rank-1 constant of {@code int} elements.
+   * Return a strided slice from `input`.
+   *  <p>
+   *  Note, most python users will want to use the Python `Tensor.__getitem__`
+   *  or `Variable.__getitem__` rather than this op directly.
+   *  <p>
+   *  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:
+   *  <p>
+   *  - 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.
+   *  <p>
+   *  - 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.
+   *  <p>
+   *  - 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]`.
+   *  <p>
+   *  - 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`.
+   *  <p>
+   *  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
+   *  <pre>{@code
+   *  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
+   *  }</pre>
+   *  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.
+   *  <p>
+   *  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`.
+   *  <p>
+   *  2. `2:4` is contributes 2, 4, 1 to begin, end, and stride. All masks have
+   *  zero bits contributed.
+   *  <p>
+   *  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.
+   *  <p>
+   *  4. `...` grab the full ranges from as many dimensions as needed to
+   *  fully specify a slice for every dimension of the input shape.
+   *  <p>
+   *  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).
+   *  <p>
+   *  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.
+   *  <p>
+   *  <i>Requirements</i>:
+   *    `0 != strides[i] for i in [0, m)`
+   *    `ellipsis_mask must be a power of two (only one ellipsis)`
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return an integer constant
+   * @param <T> data type for {@code output()} output
+   * @param input
+   * @param begin `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`.
+   * @param end `end[i]` is like `begin` with the exception that `end_mask` is
+   *  used to determine full ranges.
+   * @param strides `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`
+   * @param options carries optional attributes values
+   * @return a new instance of StridedSlice
    */
-  public Constant<TInt32> val(int[] data) {
-    return Constant.vectorOf(scope, data);
+  public <T extends TType, U extends TNumber> StridedSlice<T> stridedSlice(Operand<T> input,
+      Operand<U> begin, Operand<U> end, Operand<U> strides, StridedSlice.Options... options) {
+    return StridedSlice.create(scope, input, begin, end, strides, options);
   }
 
   /**
-   * Creates a rank-5 constant of {@code long} elements.
+   * Assign `value` to the sliced l-value reference of `ref`.
+   *  <p>
+   *  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`.
+   *  <p>
+   *  NOTE this op currently does not support broadcasting and so `value`'s
+   *  shape must be exactly the shape produced by the slice of `ref`.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a long constant
+   * @param <T> data type for {@code outputRef()} output
+   * @param ref
+   * @param begin
+   * @param end
+   * @param strides
+   * @param value
+   * @param options carries optional attributes values
+   * @return a new instance of StridedSliceAssign
    */
-  public Constant<TInt64> val(long[][][][][] data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType, U extends TNumber> StridedSliceAssign<T> stridedSliceAssign(
+      Operand<T> ref, Operand<U> begin, Operand<U> end, Operand<U> strides, Operand<T> value,
+      StridedSliceAssign.Options... options) {
+    return StridedSliceAssign.create(scope, ref, begin, end, strides, value, options);
   }
 
   /**
-   * Creates a rank-2 constant of {@code byte} elements.
+   * Returns the gradient of `StridedSlice`.
+   *  <p>
+   *  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.
+   *  <p>
+   *  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`.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a byte constant
+   * @param <U> data type for {@code output()} output
+   * @param shape
+   * @param begin
+   * @param end
+   * @param strides
+   * @param dy
+   * @param options carries optional attributes values
+   * @return a new instance of StridedSliceGrad
    */
-  public Constant<TUint8> val(byte[][] data) {
-    return Constant.tensorOf(scope, data);
+  public <U extends TType, T extends TNumber> StridedSliceGrad<U> stridedSliceGrad(Operand<T> shape,
+      Operand<T> begin, Operand<T> end, Operand<T> strides, Operand<U> dy,
+      StridedSliceGrad.Options... options) {
+    return StridedSliceGrad.create(scope, shape, begin, end, strides, dy, options);
   }
 
   /**
-   * Creates a rank-6 constant of {@code int} elements.
+   * Computes the sum of elements across dimensions of a tensor.
+   *  <p>
+   *  Reduces `input` 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 are
+   *  retained with length 1.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return an integer constant
+   * @param <T> data type for {@code output()} output
+   * @param input The tensor to reduce.
+   * @param axis The dimensions to reduce. Must be in the range
+   *  `[-rank(input), rank(input))`.
+   * @param options carries optional attributes values
+   * @return a new instance of Sum
    */
-  public Constant<TInt32> val(int[][][][][][] data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType, U extends TNumber> Sum<T> sum(Operand<T> input, Operand<U> axis,
+      Sum.Options... options) {
+    return Sum.create(scope, input, axis, options);
   }
 
   /**
-   * Creates a constant of {@code long} elements that is a copy of a given n-dimensional array.
+   * Forwards `data` to the output port determined by `pred`.
+   *  <p>
+   *  If `pred` is true, the `data` input is forwarded to `output_true`. Otherwise,
+   *  the data goes to `output_false`.
+   *  <p>
+   *  See also `RefSwitch` and `Merge`.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data an n-dimensional array of {@code long} elements.
-   * @return a long constant
+   * @param <T> data type for {@code outputFalse()} output
+   * @param data The tensor to be forwarded to the appropriate output.
+   * @param pred A scalar that specifies which output port will receive data.
+   * @return a new instance of SwitchCond
    */
-  public Constant<TInt64> val(LongNdArray data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType> SwitchCond<T> switchCond(Operand<T> data, Operand<TBool> pred) {
+    return SwitchCond.create(scope, data, pred);
   }
 
   /**
-   * Creates a rank-2 constant of {@code int} elements.
-   *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return an integer constant
-   */
-  public Constant<TInt32> val(int[][] data) {
-    return Constant.tensorOf(scope, data);
-  }
-
-  /**
-   * Creates a constant containing a single {@code boolean} element.
-   *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data The value to put into the new constant.
-   * @return a boolean constant
-   */
-  public Constant<TBool> val(boolean data) {
-    return Constant.scalarOf(scope, data);
-  }
-
-  /**
-   * Creates a rank-1 constant of {@code double} elements.
+   * Returns a tensor that may be mutated, but only persists within a single step.
+   *  <p>
+   *  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.
+   *  <p>
+   *  It is the caller's responsibility to ensure that 'ref' is eventually passed to a
+   *  matching 'DestroyTemporaryVariable' op after all other uses have completed.
+   *  <p>
+   *  Outputs a ref to the tensor state so it may be read or modified.
+   *  <p>
+   *    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)
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a double constant
+   * @param <T> data type for {@code ref()} output
+   * @param shape The shape of the variable tensor.
+   * @param dtype The type of elements in the variable tensor.
+   * @param options carries optional attributes values
+   * @return a new instance of TemporaryVariable
    */
-  public Constant<TFloat64> val(double[] data) {
-    return Constant.vectorOf(scope, data);
+  public <T extends TType> TemporaryVariable<T> temporaryVariable(Shape shape, DataType<T> dtype,
+      TemporaryVariable.Options... options) {
+    return TemporaryVariable.create(scope, shape, dtype, options);
   }
 
   /**
-   * Creates a rank-1 constant of {@code float} elements.
+   * An array of Tensors of given size.
+   *  <p>
+   *  Write data via Write and read via Read or Pack.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a float constant
+   * @param size The size of the array.
+   * @param dtype The type of the elements on the tensor_array.
+   * @param options carries optional attributes values
+   * @return a new instance of TensorArray
    */
-  public Constant<TFloat32> val(float[] data) {
-    return Constant.vectorOf(scope, data);
+  public <T extends TType> TensorArray tensorArray(Operand<TInt32> size, DataType<T> dtype,
+      TensorArray.Options... options) {
+    return TensorArray.create(scope, size, dtype, options);
   }
 
   /**
-   * Creates a rank-5 constant of {@code int} elements.
+   * Delete the TensorArray from its resource container.
+   *  <p>
+   *  This enables the user to close and release the resource in the middle
+   *  of a step/run.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return an integer constant
+   * @param handle The handle to a TensorArray (output of TensorArray or TensorArrayGrad).
+   * @return a new instance of TensorArrayClose
    */
-  public Constant<TInt32> val(int[][][][][] data) {
-    return Constant.tensorOf(scope, data);
+  public TensorArrayClose tensorArrayClose(Operand<?> handle) {
+    return TensorArrayClose.create(scope, handle);
   }
 
   /**
-   * Creates a rank-4 constant of {@code int} elements.
+   * Concat the elements from the TensorArray into value `value`.
+   *  <p>
+   *  Takes `T` elements of shapes
+   *  <p>
+   *    <pre>{@code
+   *    (n0 x d0 x d1 x ...), (n1 x d0 x d1 x ...), ..., (n(T-1) x d0 x d1 x ...)
+   *    }</pre>
+   *  and concatenates them into a Tensor of shape:
+   *  <p>
+   *    <pre>{@code
+   *  (n0 + n1 + ... + n(T-1) x d0 x d1 x ...)}</pre>
+   *  All elements must have the same shape (excepting the first dimension).
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return an integer constant
+   * @param <T> data type for {@code value()} output
+   * @param handle The handle to a TensorArray.
+   * @param flowIn A float scalar that enforces proper chaining of operations.
+   * @param dtype The type of the elem that is returned.
+   * @param options carries optional attributes values
+   * @return a new instance of TensorArrayConcat
    */
-  public Constant<TInt32> val(int[][][][] data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType> TensorArrayConcat<T> tensorArrayConcat(Operand<?> handle,
+      Operand<TFloat32> flowIn, DataType<T> dtype, TensorArrayConcat.Options... options) {
+    return TensorArrayConcat.create(scope, handle, flowIn, dtype, options);
   }
 
   /**
-   * Creates a rank-3 constant of {@code byte} elements.
+   * Gather specific elements from the TensorArray into output `value`.
+   *  <p>
+   *  All elements selected by `indices` must have the same shape.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a byte constant
+   * @param <T> data type for {@code value()} output
+   * @param handle The handle to a TensorArray.
+   * @param indices The locations in the TensorArray from which to read tensor elements.
+   * @param flowIn A float scalar that enforces proper chaining of operations.
+   * @param dtype The type of the elem that is returned.
+   * @param options carries optional attributes values
+   * @return a new instance of TensorArrayGather
    */
-  public Constant<TUint8> val(byte[][][] data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType> TensorArrayGather<T> tensorArrayGather(Operand<?> handle,
+      Operand<TInt32> indices, Operand<TFloat32> flowIn, DataType<T> dtype,
+      TensorArrayGather.Options... options) {
+    return TensorArrayGather.create(scope, handle, indices, flowIn, dtype, options);
   }
 
   /**
-   * Creates a rank-4 constant of {@code long} elements.
+   * Creates a TensorArray for storing the gradients of values in the given handle.
+   *  <p>
+   *  If the given TensorArray gradient already exists, returns a reference to it.
+   *  <p>
+   *  Locks the size of the original TensorArray by disabling its dynamic size flag.
+   *  <p>
+   * *A note about the input flow_in:**
+   *  <p>
+   *  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.
+   *  <p>
+   *  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.
+   *  <p>
+   * *A note about the source attribute:**
+   *  <p>
+   *  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.
+   *  <p>
+   *  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`).
+   *  <p>
+   *  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.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a long constant
+   * @param handle The handle to the forward TensorArray.
+   * @param flowIn A float scalar that enforces proper chaining of operations.
+   * @param source The gradient source string, used to decide which gradient TensorArray
+   *  to return.
+   * @return a new instance of TensorArrayGrad
    */
-  public Constant<TInt64> val(long[][][][] data) {
-    return Constant.tensorOf(scope, data);
+  public TensorArrayGrad tensorArrayGrad(Operand<?> handle, Operand<TFloat32> flowIn,
+      String source) {
+    return TensorArrayGrad.create(scope, handle, flowIn, source);
   }
 
   /**
-   * Creates a rank-2 constant of {@code double} elements.
+   * Creates a TensorArray for storing multiple gradients of values in the given handle.
+   *  <p>
+   *  Similar to TensorArrayGradV3. However it creates an accumulator with an
+   *  expanded shape compared to the input TensorArray whose gradient is being
+   *  computed. This enables multiple gradients for the same TensorArray to be
+   *  calculated using the same accumulator.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a double constant
+   * @param handle The handle to the forward TensorArray.
+   * @param flowIn A float scalar that enforces proper chaining of operations.
+   * @param shapeToPrepend An int32 vector representing a shape. Elements in the gradient accumulator will
+   *  have shape which is this shape_to_prepend value concatenated with shape of the
+   *  elements in the TensorArray corresponding to the input handle.
+   * @param source The gradient source string, used to decide which gradient TensorArray
+   *  to return.
+   * @return a new instance of TensorArrayGradWithShape
    */
-  public Constant<TFloat64> val(double[][] data) {
-    return Constant.tensorOf(scope, data);
+  public TensorArrayGradWithShape tensorArrayGradWithShape(Operand<?> handle,
+      Operand<TFloat32> flowIn, Operand<TInt32> shapeToPrepend, String source) {
+    return TensorArrayGradWithShape.create(scope, handle, flowIn, shapeToPrepend, source);
   }
 
   /**
-   * Creates a constant containing a single {@code long} element.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data The value to put into the new constant.
-   * @return a long constant
+   * @param <T> data type for {@code value()} output
+   * @param handle
+   * @param flowIn
+   * @param dtype
+   * @param options carries optional attributes values
+   * @return a new instance of TensorArrayPack
    */
-  public Constant<TInt64> val(long data) {
-    return Constant.scalarOf(scope, data);
+  public <T extends TType> TensorArrayPack<T> tensorArrayPack(Operand<TString> handle,
+      Operand<TFloat32> flowIn, DataType<T> dtype, TensorArrayPack.Options... options) {
+    return TensorArrayPack.create(scope, handle, flowIn, dtype, options);
   }
 
   /**
-   * Creates a constant containing a single {@code byte} element.
+   * Read an element from the TensorArray into output `value`.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data The value to put into the new constant.
-   * @return a byte constant
+   * @param <T> data type for {@code value()} output
+   * @param handle The handle to a TensorArray.
+   * @param index
+   * @param flowIn A float scalar that enforces proper chaining of operations.
+   * @param dtype The type of the elem that is returned.
+   * @return a new instance of TensorArrayRead
    */
-  public Constant<TUint8> val(byte data) {
-    return Constant.scalarOf(scope, data);
+  public <T extends TType> TensorArrayRead<T> tensorArrayRead(Operand<?> handle,
+      Operand<TInt32> index, Operand<TFloat32> flowIn, DataType<T> dtype) {
+    return TensorArrayRead.create(scope, handle, index, flowIn, dtype);
   }
 
   /**
-   * Creates a rank-3 constant of {@code long} elements.
+   * Scatter the data from the input value into specific TensorArray elements.
+   *  <p>
+   *  `indices` must be a vector, its length must match the first dim of `value`.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a long constant
+   * @param handle The handle to a TensorArray.
+   * @param indices The locations at which to write the tensor elements.
+   * @param value The concatenated tensor to write to the TensorArray.
+   * @param flowIn A float scalar that enforces proper chaining of operations.
+   * @return a new instance of TensorArrayScatter
    */
-  public Constant<TInt64> val(long[][][] data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType> TensorArrayScatter tensorArrayScatter(Operand<?> handle,
+      Operand<TInt32> indices, Operand<T> value, Operand<TFloat32> flowIn) {
+    return TensorArrayScatter.create(scope, handle, indices, value, flowIn);
   }
 
   /**
-   * Creates a constant of {@code String} elements that is a copy of a given n-dimensional array,
-   *  using the default UTF-8 encoding.
+   * Get the current size of the TensorArray.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data an n-dimensional array of {@code String} elements.
-   * @return a string constant
+   * @param handle The handle to a TensorArray (output of TensorArray or TensorArrayGrad).
+   * @param flowIn A float scalar that enforces proper chaining of operations.
+   * @return a new instance of TensorArraySize
    */
-  public Constant<TString> val(NdArray<String> data) {
-    return Constant.tensorOf(scope, data);
+  public TensorArraySize tensorArraySize(Operand<?> handle, Operand<TFloat32> flowIn) {
+    return TensorArraySize.create(scope, handle, flowIn);
   }
 
   /**
-   * Creates a rank-5 constant of {@code float} elements.
+   * Split the data from the input value into TensorArray elements.
+   *  <p>
+   *  Assuming that `lengths` takes on values
+   *  <p>
+   *    <pre>{@code
+   *  (n0, n1, ..., n(T-1))}</pre>
+   *  and that `value` has shape
+   *  <p>
+   *    <pre>{@code
+   *  (n0 + n1 + ... + n(T-1) x d0 x d1 x ...)}</pre>
+   *  ,
+   *  <p>
+   *  this splits values into a TensorArray with T tensors.
+   *  <p>
+   *  TensorArray index t will be the subtensor of values with starting position
+   *  <p>
+   *    <pre>{@code
+   *  (n0 + n1 + ... + n(t-1), 0, 0, ...)}</pre>
+   *  and having size
+   *  <p>
+   *    <pre>{@code
+   *  nt x d0 x d1 x ...}</pre>
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a float constant
+   * @param handle The handle to a TensorArray.
+   * @param value The concatenated tensor to write to the TensorArray.
+   * @param lengths The vector of lengths, how to split the rows of value into the
+   *  TensorArray.
+   * @param flowIn A float scalar that enforces proper chaining of operations.
+   * @return a new instance of TensorArraySplit
    */
-  public Constant<TFloat32> val(float[][][][][] data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType> TensorArraySplit tensorArraySplit(Operand<?> handle, Operand<T> value,
+      Operand<TInt64> lengths, Operand<TFloat32> flowIn) {
+    return TensorArraySplit.create(scope, handle, value, lengths, flowIn);
   }
 
   /**
-   * Creates a rank-6 constant of {@code byte} elements.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a byte constant
+   * @param handle
+   * @param value
+   * @param flowIn
+   * @return a new instance of TensorArrayUnpack
    */
-  public Constant<TUint8> val(byte[][][][][][] data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType> TensorArrayUnpack tensorArrayUnpack(Operand<TString> handle,
+      Operand<T> value, Operand<TFloat32> flowIn) {
+    return TensorArrayUnpack.create(scope, handle, value, flowIn);
   }
 
   /**
-   * Creates a rank-3 constant of {@code double} elements.
+   * Push an element onto the tensor_array.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a double constant
+   * @param handle The handle to a TensorArray.
+   * @param index The position to write to inside the TensorArray.
+   * @param value The tensor to write to the TensorArray.
+   * @param flowIn A float scalar that enforces proper chaining of operations.
+   * @return a new instance of TensorArrayWrite
    */
-  public Constant<TFloat64> val(double[][][] data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType> TensorArrayWrite tensorArrayWrite(Operand<?> handle,
+      Operand<TInt32> index, Operand<T> value, Operand<TFloat32> flowIn) {
+    return TensorArrayWrite.create(scope, handle, index, value, flowIn);
   }
 
   /**
-   * Creates a rank-2 constant of {@code boolean} elements.
+   * Concats all tensors in the list along the 0th dimension.
+   *  <p>
+   *  Requires that all tensors have the same shape except the first dimension.
+   *  <p>
+   *  input_handle: The input list.
+   *  element_shape: The shape of the uninitialized elements in the list. If the first
+   *    dimension is not -1, it is assumed that all list elements have the same
+   *    leading dim.
+   *  leading_dims: The list of leading dims of uninitialized list elements. Used if
+   *    the leading dim of input_handle.element_shape or the element_shape input arg
+   *    is not already set.
+   *  tensor: The concated result.
+   *  lengths: Output tensor containing sizes of the 0th dimension of tensors in the list, used for computing the gradient.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a boolean constant
+   * @param <U> data type for {@code tensor()} output
+   * @param inputHandle
+   * @param elementShape
+   * @param leadingDims
+   * @param elementDtype
+   * @return a new instance of TensorListConcat
    */
-  public Constant<TBool> val(boolean[][] data) {
-    return Constant.tensorOf(scope, data);
+  public <U extends TType, T extends TNumber> TensorListConcat<U> tensorListConcat(
+      Operand<?> inputHandle, Operand<T> elementShape, Operand<TInt64> leadingDims,
+      DataType<U> elementDtype) {
+    return TensorListConcat.create(scope, inputHandle, elementShape, leadingDims, elementDtype);
   }
 
   /**
-   * Creates a rank-2 constant of {@code float} elements.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a float constant
+   * @param inputA
+   * @param inputB
+   * @param elementDtype
+   * @return a new instance of TensorListConcatLists
    */
-  public Constant<TFloat32> val(float[][] data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType> TensorListConcatLists tensorListConcatLists(Operand<?> inputA,
+      Operand<?> inputB, DataType<T> elementDtype) {
+    return TensorListConcatLists.create(scope, inputA, inputB, elementDtype);
   }
 
   /**
-   * Creates a rank-1 constant of {@code boolean} elements.
+   * The shape of the elements of the given list, as a tensor.
+   *  <p>
+   *    input_handle: the list
+   *    element_shape: the shape of elements of the list
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a boolean constant
+   * @param <T> data type for {@code elementShape()} output
+   * @param inputHandle
+   * @param shapeType
+   * @return a new instance of TensorListElementShape
    */
-  public Constant<TBool> val(boolean[] data) {
-    return Constant.vectorOf(scope, data);
+  public <T extends TNumber> TensorListElementShape<T> tensorListElementShape(
+      Operand<?> inputHandle, DataType<T> shapeType) {
+    return TensorListElementShape.create(scope, inputHandle, shapeType);
   }
 
   /**
-   * Creates a rank-4 constant of {@code byte} elements.
+   * Creates a TensorList which, when stacked, has the value of `tensor`.
+   *  <p>
+   *  Each tensor in the result list corresponds to one row of the input tensor.
+   *  <p>
+   *  tensor: The input tensor.
+   *  output_handle: The list.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a byte constant
+   * @param tensor
+   * @param elementShape
+   * @return a new instance of TensorListFromTensor
    */
-  public Constant<TUint8> val(byte[][][][] data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType, U extends TNumber> TensorListFromTensor tensorListFromTensor(
+      Operand<T> tensor, Operand<U> elementShape) {
+    return TensorListFromTensor.create(scope, tensor, elementShape);
   }
 
   /**
-   * Creates a constant of {@code int} elements that is a copy of a given n-dimensional array.
+   * Creates a Tensor by indexing into the TensorList.
+   *  <p>
+   *  Each row in the produced Tensor corresponds to the element in the TensorList
+   *  specified by the given index (see `tf.gather`).  
+   *  <p>
+   *  input_handle: The input tensor list.
+   *  indices: The indices used to index into the list.
+   *  values: The tensor.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data an n-dimensional array of {@code int} elements.
-   * @return an integer constant
+   * @param <T> data type for {@code values()} output
+   * @param inputHandle
+   * @param indices
+   * @param elementShape
+   * @param elementDtype
+   * @return a new instance of TensorListGather
    */
-  public Constant<TInt32> val(IntNdArray data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType> TensorListGather<T> tensorListGather(Operand<?> inputHandle,
+      Operand<TInt32> indices, Operand<TInt32> elementShape, DataType<T> elementDtype) {
+    return TensorListGather.create(scope, inputHandle, indices, elementShape, elementDtype);
   }
 
   /**
-   * Creates a rank-6 constant of {@code long} elements.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param data An array containing the values to put into the new constant. The dimensions of the
-   *      new constant will match those of the array.
-   * @return a long constant
+   * @param <T> data type for {@code item()} output
+   * @param inputHandle
+   * @param index
+   * @param elementShape
+   * @param elementDtype
+   * @return a new instance of TensorListGetItem
    */
-  public Constant<TInt64> val(long[][][][][][] data) {
-    return Constant.tensorOf(scope, data);
+  public <T extends TType> TensorListGetItem<T> tensorListGetItem(Operand<?> inputHandle,
+      Operand<TInt32> index, Operand<TInt32> elementShape, DataType<T> elementDtype) {
+    return TensorListGetItem.create(scope, inputHandle, index, elementShape, elementDtype);
   }
 
   /**
-   * Creates a rank-1 constant of {@code long} elements representing the size of each dimensions of
-   *  the given shape.
+   * Returns the number of tensors in the input tensor list.
+   *  <p>
+   *  input_handle: the input list
+   *  length: the number of tensors in the list
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param shape a shape
-   * @return a long constant
+   * @param inputHandle
+   * @return a new instance of TensorListLength
    */
-  public Constant<TInt64> val(Shape shape) {
-    return Constant.tensorOf(scope, shape);
+  public TensorListLength tensorListLength(Operand<?> inputHandle) {
+    return TensorListLength.create(scope, inputHandle);
   }
 
   /**
-   * Create a constant from a Tensor.
+   * Returns the last element of the input list as well as a list with all but that element.
+   *  <p>
+   *  Fails if the list is empty.
+   *  <p>
+   *  input_handle: the input list
+   *  tensor: the withdrawn last element of the list
+   *  element_dtype: the type of elements in the list
+   *  element_shape: the shape of the output tensor
+   *
+   * @param <T> data type for {@code tensor()} output
+   * @param inputHandle
+   * @param elementShape
+   * @param elementDtype
+   * @return a new instance of TensorListPopBack
+   */
+  public <T extends TType> TensorListPopBack<T> tensorListPopBack(Operand<?> inputHandle,
+      Operand<TInt32> elementShape, DataType<T> elementDtype) {
+    return TensorListPopBack.create(scope, inputHandle, elementShape, elementDtype);
+  }
+
+  /**
+   * Returns a list which has the passed-in `Tensor` as last element and the other elements of the given list in `input_handle`.
+   *  <p>
+   *  tensor: The tensor to put on the list.
+   *  input_handle: The old list.
+   *  output_handle: A list with the elements of the old list followed by tensor.
+   *  element_dtype: the type of elements in the list.
+   *  element_shape: a shape compatible with that of elements in the list.
+   *
+   * @param inputHandle
+   * @param tensor
+   * @return a new instance of TensorListPushBack
+   */
+  public <T extends TType> TensorListPushBack tensorListPushBack(Operand<?> inputHandle,
+      Operand<T> tensor) {
+    return TensorListPushBack.create(scope, inputHandle, tensor);
+  }
+
+  /**
+   *
+   * @param inputHandles
+   * @param tensor
+   * @return a new instance of TensorListPushBackBatch
+   */
+  public <T extends TType> TensorListPushBackBatch tensorListPushBackBatch(Operand<?> inputHandles,
+      Operand<T> tensor) {
+    return TensorListPushBackBatch.create(scope, inputHandles, tensor);
+  }
+
+  /**
+   * List of the given size with empty elements.
+   *  <p>
+   *  element_shape: the shape of the future elements of the list
+   *  num_elements: the number of elements to reserve
+   *  handle: the output list
+   *  element_dtype: the desired type of elements in the list.
+   *
+   * @param elementShape
+   * @param numElements
+   * @param elementDtype
+   * @return a new instance of TensorListReserve
+   */
+  public <T extends TNumber, U extends TType> TensorListReserve tensorListReserve(
+      Operand<T> elementShape, Operand<TInt32> numElements, DataType<U> elementDtype) {
+    return TensorListReserve.create(scope, elementShape, numElements, elementDtype);
+  }
+
+  /**
+   * Resizes the list.
+   *  <p>
+   *
+   *  input_handle: the input list
+   *  size: size of the output list
+   *
+   * @param inputHandle
+   * @param size
+   * @return a new instance of TensorListResize
+   */
+  public TensorListResize tensorListResize(Operand<?> inputHandle, Operand<TInt32> size) {
+    return TensorListResize.create(scope, inputHandle, size);
+  }
+
+  /**
+   * Creates a TensorList by indexing into a Tensor.
+   *  <p>
+   *  Each member of the TensorList corresponds to one row of the input tensor,
+   *  specified by the given index (see `tf.gather`).
+   *  <p>
+   *  tensor: The input tensor.
+   *  indices: The indices used to index into the list.
+   *  element_shape: The shape of the elements in the list (can be less specified than
+   *    the shape of the tensor).
+   *  num_elements: The size of the output list. Must be large enough to accommodate
+   *    the largest index in indices. If -1, the list is just large enough to include
+   *    the largest index in indices.
+   *  output_handle: The TensorList.
+   *
+   * @param tensor
+   * @param indices
+   * @param elementShape
+   * @param numElements
+   * @return a new instance of TensorListScatter
+   */
+  public <T extends TType, U extends TNumber> TensorListScatter tensorListScatter(Operand<T> tensor,
+      Operand<TInt32> indices, Operand<U> elementShape, Operand<TInt32> numElements) {
+    return TensorListScatter.create(scope, tensor, indices, elementShape, numElements);
+  }
+
+  /**
+   * Scatters tensor at indices in an input list.
+   *  <p>
+   *  Each member of the TensorList corresponds to one row of the input tensor,
+   *  specified by the given index (see `tf.gather`).
+   *  <p>
+   *  input_handle: The list to scatter into.
+   *  tensor: The input tensor.
+   *  indices: The indices used to index into the list.
+   *  output_handle: The TensorList.
+   *
+   * @param inputHandle
+   * @param tensor
+   * @param indices
+   * @return a new instance of TensorListScatterIntoExistingList
+   */
+  public <T extends TType> TensorListScatterIntoExistingList tensorListScatterIntoExistingList(
+      Operand<?> inputHandle, Operand<T> tensor, Operand<TInt32> indices) {
+    return TensorListScatterIntoExistingList.create(scope, inputHandle, tensor, indices);
+  }
+
+  /**
+   *
+   * @param inputHandle
+   * @param index
+   * @param item
+   * @return a new instance of TensorListSetItem
+   */
+  public <T extends TType> TensorListSetItem tensorListSetItem(Operand<?> inputHandle,
+      Operand<TInt32> index, Operand<T> item) {
+    return TensorListSetItem.create(scope, inputHandle, index, item);
+  }
+
+  /**
+   * Splits a tensor into a list.
+   *  <p>
+   *  list[i] corresponds to lengths[i] tensors from the input tensor.
+   *  The tensor must have rank at least 1 and contain exactly sum(lengths) elements.
+   *  <p>
+   *  tensor: The input tensor.
+   *  element_shape: A shape compatible with that of elements in the tensor.
+   *  lengths: Vector of sizes of the 0th dimension of tensors in the list.
+   *  output_handle: The list.
+   *
+   * @param tensor
+   * @param elementShape
+   * @param lengths
+   * @return a new instance of TensorListSplit
+   */
+  public <T extends TType, U extends TNumber> TensorListSplit tensorListSplit(Operand<T> tensor,
+      Operand<U> elementShape, Operand<TInt64> lengths) {
+    return TensorListSplit.create(scope, tensor, elementShape, lengths);
+  }
+
+  /**
+   * Stacks all tensors in the list.
+   *  <p>
+   *  Requires that all tensors have the same shape.
+   *  <p>
+   *  input_handle: the input list
+   *  tensor: the gathered result
+   *  num_elements: optional. If not -1, the number of elements in the list.
+   *
+   * @param <T> data type for {@code tensor()} output
+   * @param inputHandle
+   * @param elementShape
+   * @param elementDtype
+   * @param options carries optional attributes values
+   * @return a new instance of TensorListStack
+   */
+  public <T extends TType> TensorListStack<T> tensorListStack(Operand<?> inputHandle,
+      Operand<TInt32> elementShape, DataType<T> elementDtype, TensorListStack.Options... options) {
+    return TensorListStack.create(scope, inputHandle, elementShape, elementDtype, options);
+  }
+
+  /**
+   * Adds sparse `updates` to an existing tensor according to `indices`.
+   *  <p>
+   *  This operation creates a new tensor by adding sparse `updates` to the passed
+   *  in `tensor`.
+   *  This operation is very similar to `tf.scatter_nd_add`, except that the updates
+   *  are added onto an existing tensor (as opposed to a variable). If the memory
+   *  for the existing tensor cannot be re-used, a copy is made and updated.
+   *  <p>
+   *  `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`:
+   *  <p>
+   *      indices.shape[-1] <= shape.rank
+   *  <p>
+   *  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
+   *  <p>
+   *      indices.shape[:-1] + shape[indices.shape[-1]:]
+   *  <p>
+   *  The simplest form of tensor_scatter_add is to add individual elements to a
+   *  tensor by index. For example, say we want to add 4 elements in a rank-1
+   *  tensor with 8 elements.
+   *  <p>
+   *  In Python, this scatter add operation would look like this:
+   *  <pre>{@code
+   *      indices = tf.constant([[4], [3], [1], [7]])
+   *      updates = tf.constant([9, 10, 11, 12])
+   *      tensor = tf.ones([8], dtype=tf.int32)
+   *      updated = tf.tensor_scatter_nd_add(tensor, indices, updates)
+   *      print(updated)
+   *  }</pre>
+   *  The resulting tensor would look like this:
+   *  <p>
+   *      [1, 12, 1, 11, 10, 1, 1, 13]
+   *  <p>
+   *  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.
+   *  <p>
+   *  In Python, this scatter add operation would look like this:
+   *  <pre>{@code
+   *      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]]])
+   *      tensor = tf.ones([4, 4, 4],dtype=tf.int32)
+   *      updated = tf.tensor_scatter_nd_add(tensor, indices, updates)
+   *      print(updated)
+   *  }</pre>
+   *  The resulting tensor would look like this:
+   *  <p>
+   *      [[[6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8], [9, 9, 9, 9]],
+   *       [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
+   *       [[6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8], [9, 9, 9, 9]],
+   *       [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]
+   *  <p>
+   *  Note that on CPU, if an out of bound index is found, an error is returned.
+   *  On GPU, if an out of bound index is found, the index is ignored.
+   *
+   * @param <T> data type for {@code output()} output
+   * @param tensor Tensor to copy/update.
+   * @param indices Index tensor.
+   * @param updates Updates to scatter into output.
+   * @return a new instance of TensorScatterNdAdd
+   */
+  public <T extends TType, U extends TNumber> TensorScatterNdAdd<T> tensorScatterNdAdd(
+      Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
+    return TensorScatterNdAdd.create(scope, tensor, indices, updates);
+  }
+
+  /**
+   * Subtracts sparse `updates` from an existing tensor according to `indices`.
+   *  <p>
+   *  This operation creates a new tensor by subtracting sparse `updates` from the
+   *  passed in `tensor`.
+   *  This operation is very similar to `tf.scatter_nd_sub`, except that the updates
+   *  are subtracted from an existing tensor (as opposed to a variable). If the memory
+   *  for the existing tensor cannot be re-used, a copy is made and updated.
+   *  <p>
+   *  `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`:
+   *  <p>
+   *      indices.shape[-1] <= shape.rank
+   *  <p>
+   *  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
+   *  <p>
+   *      indices.shape[:-1] + shape[indices.shape[-1]:]
+   *  <p>
+   *  The simplest form of tensor_scatter_sub is to subtract individual elements
+   *  from a tensor by index. For example, say we want to insert 4 scattered elements
+   *  in a rank-1 tensor with 8 elements.
+   *  <p>
+   *  In Python, this scatter subtract operation would look like this:
+   *  <pre>{@code
+   *      indices = tf.constant([[4], [3], [1], [7]])
+   *      updates = tf.constant([9, 10, 11, 12])
+   *      tensor = tf.ones([8], dtype=tf.int32)
+   *      updated = tf.tensor_scatter_nd_sub(tensor, indices, updates)
+   *      print(updated)
+   *  }</pre>
+   *  The resulting tensor would look like this:
+   *  <p>
+   *      [1, -10, 1, -9, -8, 1, 1, -11]
+   *  <p>
+   *  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.
+   *  <p>
+   *  In Python, this scatter add operation would look like this:
+   *  <pre>{@code
+   *      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]]])
+   *      tensor = tf.ones([4, 4, 4],dtype=tf.int32)
+   *      updated = tf.tensor_scatter_nd_sub(tensor, indices, updates)
+   *      print(updated)
+   *  }</pre>
+   *  The resulting tensor would look like this:
+   *  <p>
+   *      [[[-4, -4, -4, -4], [-5, -5, -5, -5], [-6, -6, -6, -6], [-7, -7, -7, -7]],
+   *       [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
+   *       [[-4, -4, -4, -4], [-5, -5, -5, -5], [-6, -6, -6, -6], [-7, -7, -7, -7]],
+   *       [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]
+   *  <p>
+   *  Note that on CPU, if an out of bound index is found, an error is returned.
+   *  On GPU, if an out of bound index is found, the index is ignored.
+   *
+   * @param <T> data type for {@code output()} output
+   * @param tensor Tensor to copy/update.
+   * @param indices Index tensor.
+   * @param updates Updates to scatter into output.
+   * @return a new instance of TensorScatterNdSub
+   */
+  public <T extends TType, U extends TNumber> TensorScatterNdSub<T> tensorScatterNdSub(
+      Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
+    return TensorScatterNdSub.create(scope, tensor, indices, updates);
+  }
+
+  /**
+   * Scatter `updates` into an existing tensor according to `indices`.
+   *  <p>
+   *  This operation creates a new tensor by applying sparse `updates` to the passed
+   *  in `tensor`.
+   *  This operation is very similar to `tf.scatter_nd`, except that the updates are
+   *  scattered onto an existing tensor (as opposed to a zero-tensor). If the memory
+   *  for the existing tensor cannot be re-used, a copy is made and updated.
+   *  <p>
+   *  If `indices` contains duplicates, then their updates are accumulated (summed).
+   *  <p>
+   *  <b>WARNING</b>: The order in which updates are applied is nondeterministic, so the
+   *  output will be nondeterministic if `indices` contains duplicates -- because
+   *  of some numerical approximation issues, numbers summed in different order
+   *  may yield different results.
+   *  <p>
+   *  `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`:
+   *  <p>
+   *      indices.shape[-1] <= shape.rank
+   *  <p>
+   *  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
+   *  <p>
+   *      indices.shape[:-1] + shape[indices.shape[-1]:]
+   *  <p>
+   *  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.
+   *  <p>
+   *  <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>
+   *  <p>
+   *  In Python, this scatter operation would look like this:
+   *  <pre>{@code
+   *      indices = tf.constant([[4], [3], [1], [7]])
+   *      updates = tf.constant([9, 10, 11, 12])
+   *      tensor = tf.ones([8], dtype=tf.int32)
+   *      updated = tf.tensor_scatter_nd_update(tensor, indices, updates)
+   *      print(updated)
+   *  }</pre>
+   *  The resulting tensor would look like this:
+   *  <p>
+   *      [1, 11, 1, 10, 9, 1, 1, 12]
+   *  <p>
+   *  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.
+   *  <p>
+   *  In Python, this scatter operation would look like this:
+   *  <pre>{@code
+   *      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]]])
+   *      tensor = tf.ones([4, 4, 4],dtype=tf.int32)
+   *      updated = tf.tensor_scatter_nd_update(tensor, indices, updates)
+   *      print(updated)
+   *  }</pre>
+   *  The resulting tensor would look like this:
+   *  <p>
+   *      [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+   *       [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
+   *       [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+   *       [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]
+   *  <p>
+   *  Note that on CPU, if an out of bound index is found, an error is returned.
+   *  On GPU, if an out of bound index is found, the index is ignored.
+   *
+   * @param <T> data type for {@code output()} output
+   * @param tensor Tensor to copy/update.
+   * @param indices Index tensor.
+   * @param updates Updates to scatter into output.
+   * @return a new instance of TensorScatterNdUpdate
+   */
+  public <T extends TType, U extends TNumber> TensorScatterNdUpdate<T> tensorScatterNdUpdate(
+      Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
+    return TensorScatterNdUpdate.create(scope, tensor, indices, updates);
+  }
+
+  /**
+   * Assign `value` to the sliced l-value reference of `input`.
+   *  <p>
+   *  The values of `value` are assigned to the positions in the tensor `input` that
+   *  are selected by the slice parameters. The slice parameters `begin` `end`
+   *  `strides` etc. work exactly as in `StridedSlice`.
+   *  <p>
+   *  NOTE this op currently does not support broadcasting and so `value`'s shape
+   *  must be exactly the shape produced by the slice of `input`.
+   *
+   * @param <T> data type for {@code output()} output
+   * @param input
+   * @param begin
+   * @param end
+   * @param strides
+   * @param value
+   * @param options carries optional attributes values
+   * @return a new instance of TensorStridedSliceUpdate
+   */
+  public <T extends TType, U extends TNumber> TensorStridedSliceUpdate<T> tensorStridedSliceUpdate(
+      Operand<T> input, Operand<U> begin, Operand<U> end, Operand<U> strides, Operand<T> value,
+      TensorStridedSliceUpdate.Options... options) {
+    return TensorStridedSliceUpdate.create(scope, input, begin, end, strides, value, options);
+  }
+
+  /**
+   * Constructs a tensor by tiling a given tensor.
+   *  <p>
+   *  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]`.
+   *  <p>
+   *  >>> a = tf.constant([[1,2,3],[4,5,6]], tf.int32)
+   *  >>> b = tf.constant([1,2], tf.int32)
+   *  >>> tf.tile(a, b)
+   *  <tf.Tensor: shape=(2, 6), dtype=int32, numpy=
+   *  array([[1, 2, 3, 1, 2, 3],
+   *         [4, 5, 6, 4, 5, 6]], dtype=int32)>
+   *  >>> c = tf.constant([2,1], tf.int32)
+   *  >>> tf.tile(a, c)
+   *  <tf.Tensor: shape=(4, 3), dtype=int32, numpy=
+   *  array([[1, 2, 3],
+   *         [4, 5, 6],
+   *         [1, 2, 3],
+   *         [4, 5, 6]], dtype=int32)>
+   *  >>> d = tf.constant([2,2], tf.int32)
+   *  >>> tf.tile(a, d)
+   *  <tf.Tensor: shape=(4, 6), dtype=int32, numpy=
+   *  array([[1, 2, 3, 1, 2, 3],
+   *         [4, 5, 6, 4, 5, 6],
+   *         [1, 2, 3, 1, 2, 3],
+   *         [4, 5, 6, 4, 5, 6]], dtype=int32)>
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param tensor a Tensor holding the constant value
-   * @return a constant of the same data type as `tensor`
+   * @param <T> data type for {@code output()} output
+   * @param input 1-D or higher.
+   * @param multiples 1-D. Length must be the same as the number of dimensions in `input`
+   * @return a new instance of Tile
    */
-  public <T extends TType> Constant<T> val(Tensor<T> tensor) {
-    return Constant.create(scope, tensor);
+  public <T extends TType, U extends TNumber> Tile<T> tile(Operand<T> input, Operand<U> multiples) {
+    return Tile.create(scope, input, multiples);
   }
 
   /**
-   * Creates a constant of {@code String} elements, using the given charset.
+   * Provides the time since epoch in seconds.
+   *  <p>
+   *  Returns the timestamp as a `float64` for seconds since the Unix epoch.
+   *  <p>
+   *  Note: the timestamp is computed when the op is executed, not when it is added
+   *  to the graph.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param charset charset for encoding/decoding strings bytes.
-   * @param data An array containing the values to put into the new constant. String elements are
-   *      sequences of bytes from the last array dimension.
-   * @return the {@code String} constant
+   * @return a new instance of Timestamp
    */
-  public Constant<TString> val(Charset charset, String[] data) {
-    return Constant.vectorOf(scope, charset, data);
+  public Timestamp timestamp() {
+    return Timestamp.create(scope);
   }
 
   /**
-   * Creates a {@code String} constant using a specified encoding.
+   * Perform batches of RPC requests.
+   *  <p>
+   *  This op asynchronously performs either a single RPC request, or a batch
+   *  of requests.  RPC requests are defined by three main parameters:
+   *  <p>
+   *    - `address` (the host+port or BNS address of the request)
+   *    - `method` (the method name for the request)
+   *    - `request` (the serialized proto string, or vector of strings,
+   *       of the RPC request argument).
+   *  <p>
+   *  For example, if you have an RPC service running on port localhost:2345,
+   *  and its interface is configured with the following proto declaration:
+   *  <pre>{@code
+   *  service MyService {
+   *    rpc MyMethod(MyRequestProto) returns (MyResponseProto) {
+   *    }
+   *  };
+   *  }</pre>
+   *  then call this op with arguments:
+   *  <pre>{@code
+   *  address = "localhost:2345"
+   *  method = "MyService/MyMethod"
+   *  }</pre>
+   *  The `request` tensor is a string tensor representing serialized `MyRequestProto`
+   *  strings; and the output string tensor `response` will have the same shape
+   *  and contain (upon successful completion) corresponding serialized
+   *  `MyResponseProto` strings.
+   *  <p>
+   *  For example, to send a single, empty, `MyRequestProto`, call
+   *  this op with `request = ""`.  To send 5 <b>parallel</b> empty requests,
+   *  call this op with `request = ["", "", "", "", ""]`.
+   *  <p>
+   *  More generally, one can create a batch of `MyRequestProto` serialized protos
+   *  from regular batched tensors using the `encode_proto` op, and convert
+   *  the response `MyResponseProto` serialized protos to batched tensors
+   *  using the `decode_proto` op.
+   *  <p>
+   *  <b>NOTE</b> Working with serialized proto strings is faster than instantiating
+   *  actual proto objects in memory, so no performance degradation is expected
+   *  compared to writing custom kernels for this workflow.
+   *  <p>
+   *  Unlike the standard `Rpc` op, if the connection fails or the remote worker
+   *  returns an error status, this op does <b>not</b> reraise the exception.
+   *  Instead, the `status_code` and `status_message` entry for the corresponding RPC
+   *  call is set with the error returned from the RPC call.  The `response` tensor
+   *  will contain valid response values for those minibatch entries whose RPCs did
+   *  not fail; the rest of the entries will have empty strings.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param charset The encoding from String to bytes.
-   * @param data The string to put into the new constant.
-   * @return a string constant
+   * @param address `0-D` or `1-D`.  The address (i.e. host_name:port) of the RPC server.
+   *  If this tensor has more than 1 element, then multiple parallel rpc requests
+   *  are sent.  This argument broadcasts with `method` and `request`.
+   * @param method `0-D` or `1-D`.  The method address on the RPC server.
+   *  If this tensor has more than 1 element, then multiple parallel rpc requests
+   *  are sent.  This argument broadcasts with `address` and `request`.
+   * @param request `0-D` or `1-D`.  Serialized proto strings: the rpc request argument.
+   *  If this tensor has more than 1 element, then multiple parallel rpc requests
+   *  are sent.  This argument broadcasts with `address` and `method`.
+   * @param options carries optional attributes values
+   * @return a new instance of TryRpc
    */
-  public Constant<TString> val(Charset charset, String data) {
-    return Constant.scalarOf(scope, charset, data);
+  public TryRpc tryRpc(Operand<TString> address, Operand<TString> method, Operand<TString> request,
+      TryRpc.Options... options) {
+    return TryRpc.create(scope, address, method, request, options);
   }
 
   /**
-   * Creates a constant of {@code String} elements that is a copy of a given n-dimensional array,
-   *  using the given encoding.
+   * Reverses the operation of Batch for a single output Tensor.
+   *  <p>
+   *  An instance of Unbatch either receives an empty batched_tensor, in which case it
+   *  asynchronously waits until the values become available from a concurrently
+   *  running instance of Unbatch with the same container and shared_name, or receives
+   *  a non-empty batched_tensor in which case it finalizes all other concurrently
+   *  running instances and outputs its own element from the batch.
+   *  <p>
+   *  batched_tensor: The possibly transformed output of Batch. The size of the first
+   *   dimension should remain unchanged by the transformations for the operation to
+   *   work.
+   *  batch_index: The matching batch_index obtained from Batch.
+   *  id: The id scalar emitted by Batch.
+   *  unbatched_tensor: The Tensor corresponding to this execution.
+   *  timeout_micros: Maximum amount of time (in microseconds) to wait to receive the
+   *   batched input tensor associated with a given invocation of the op.
+   *  container: Container to control resource sharing.
+   *  shared_name: Instances of Unbatch with the same container and shared_name are
+   *   assumed to possibly belong to the same batch. If left empty, the op name will
+   *   be used as the shared name.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param charset charset used to encode/decode string bytes.
-   * @param data an n-dimensional array of {@code String} elements.
-   * @return a string constant
+   * @param <T> data type for {@code unbatchedTensor()} output
+   * @param batchedTensor
+   * @param batchIndex
+   * @param id
+   * @param timeoutMicros
+   * @param options carries optional attributes values
+   * @return a new instance of Unbatch
    */
-  public Constant<TString> val(Charset charset, NdArray<String> data) {
-    return Constant.tensorOf(scope, charset, data);
+  public <T extends TType> Unbatch<T> unbatch(Operand<T> batchedTensor, Operand<TInt64> batchIndex,
+      Operand<TInt64> id, Long timeoutMicros, Unbatch.Options... options) {
+    return Unbatch.create(scope, batchedTensor, batchIndex, id, timeoutMicros, options);
   }
 
   /**
-   * Create a {@link TInt64} constant with data from the given buffer.
+   * Gradient of Unbatch.
+   *  <p>
+   *  Acts like Batch but using the given batch_index index of batching things as they
+   *  become available. This ensures that the gradients are propagated back in the
+   *  same session which did the forward pass.
+   *  <p>
+   *  original_input: The input to the Unbatch operation this is the gradient of.
+   *  batch_index: The batch_index given to the Unbatch operation this is the gradient
+   *  of.
+   *  grad: The downstream gradient.
+   *  id: The id scalar emitted by Batch.
+   *  batched_grad: The return value, either an empty tensor or the batched gradient.
+   *  container: Container to control resource sharing.
+   *  shared_name: Instances of UnbatchGrad with the same container and shared_name
+   *   are assumed to possibly belong to the same batch. If left empty, the op name
+   *   will be used as the shared name.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param shape the tensor shape.
-   * @param data a buffer containing the tensor data.
-   * @return a long constant
-   * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
+   * @param <T> data type for {@code batchedGrad()} output
+   * @param originalInput
+   * @param batchIndex
+   * @param grad
+   * @param id
+   * @param options carries optional attributes values
+   * @return a new instance of UnbatchGrad
    */
-  public Constant<TInt64> val(Shape shape, LongDataBuffer data) {
-    return Constant.tensorOf(scope, shape, data);
+  public <T extends TType> UnbatchGrad<T> unbatchGrad(Operand<T> originalInput,
+      Operand<TInt64> batchIndex, Operand<T> grad, Operand<TInt64> id,
+      UnbatchGrad.Options... options) {
+    return UnbatchGrad.create(scope, originalInput, batchIndex, grad, id, options);
   }
 
   /**
-   * Create a {@link TFloat64} constant with data from the given buffer.
+   * Finds unique elements along an axis of a tensor.
+   *  <p>
+   *  This operation either returns a tensor `y` containing unique elements
+   *  along the `axis` of a tensor. The returned unique elements is sorted
+   *  in the same order as they occur along `axis` in `x`.
+   *  This operation also returns a tensor `idx` that is the same size as
+   *  the number of the elements in `x` along the `axis` dimension. It
+   *  contains the index in the unique output `y`.
+   *  In other words, for an `1-D` tensor `x` with `axis = None:
+   *  <p>
+   *  `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
+   *  <p>
+   *  For example:
+   *  <pre>{@code
+   *  # 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]
+   *  }</pre>
+   *  For an `2-D` tensor `x` with `axis = 0`:
+   *  <pre>{@code
+   *  # tensor 'x' is [[1, 0, 0],
+   *  #                [1, 0, 0],
+   *  #                [2, 0, 0]]
+   *  y, idx = unique(x, axis=0)
+   *  y ==> [[1, 0, 0],
+   *         [2, 0, 0]]
+   *  idx ==> [0, 0, 1]
+   *  }</pre>
+   *  For an `2-D` tensor `x` with `axis = 1`:
+   *  <pre>{@code
+   *  # tensor 'x' is [[1, 0, 0],
+   *  #                [1, 0, 0],
+   *  #                [2, 0, 0]]
+   *  y, idx = unique(x, axis=1)
+   *  y ==> [[1, 0],
+   *         [1, 0],
+   *         [2, 0]]
+   *  idx ==> [0, 1, 1]
+   *  }</pre>
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param shape the tensor shape.
-   * @param data a buffer containing the tensor data.
-   * @return a double constant
-   * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
+   * @param <T> data type for {@code y()} output
+   * @param <V> data type for {@code idx()} output
+   * @param x A `Tensor`.
+   * @param axis A `Tensor` of type `int32` (default: None). The axis of the Tensor to
+   *  find the unique elements.
+   * @return a new instance of Unique
    */
-  public Constant<TFloat64> val(Shape shape, DoubleDataBuffer data) {
-    return Constant.tensorOf(scope, shape, data);
+  public <T extends TType, U extends TNumber> Unique<T, TInt32> unique(Operand<T> x,
+      Operand<U> axis) {
+    return Unique.create(scope, x, axis);
   }
 
   /**
-   * Create a {@link TFloat32} constant with data from the given buffer.
+   * Finds unique elements along an axis of a tensor.
+   *  <p>
+   *  This operation either returns a tensor `y` containing unique elements
+   *  along the `axis` of a tensor. The returned unique elements is sorted
+   *  in the same order as they occur along `axis` in `x`.
+   *  This operation also returns a tensor `idx` that is the same size as
+   *  the number of the elements in `x` along the `axis` dimension. It
+   *  contains the index in the unique output `y`.
+   *  In other words, for an `1-D` tensor `x` with `axis = None:
+   *  <p>
+   *  `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
+   *  <p>
+   *  For example:
+   *  <pre>{@code
+   *  # 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]
+   *  }</pre>
+   *  For an `2-D` tensor `x` with `axis = 0`:
+   *  <pre>{@code
+   *  # tensor 'x' is [[1, 0, 0],
+   *  #                [1, 0, 0],
+   *  #                [2, 0, 0]]
+   *  y, idx = unique(x, axis=0)
+   *  y ==> [[1, 0, 0],
+   *         [2, 0, 0]]
+   *  idx ==> [0, 0, 1]
+   *  }</pre>
+   *  For an `2-D` tensor `x` with `axis = 1`:
+   *  <pre>{@code
+   *  # tensor 'x' is [[1, 0, 0],
+   *  #                [1, 0, 0],
+   *  #                [2, 0, 0]]
+   *  y, idx = unique(x, axis=1)
+   *  y ==> [[1, 0],
+   *         [1, 0],
+   *         [2, 0]]
+   *  idx ==> [0, 1, 1]
+   *  }</pre>
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param shape the tensor shape.
-   * @param data a buffer containing the tensor data.
-   * @return a float constant
-   * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
+   * @param <T> data type for {@code y()} output
+   * @param <V> data type for {@code idx()} output
+   * @param x A `Tensor`.
+   * @param axis A `Tensor` of type `int32` (default: None). The axis of the Tensor to
+   *  find the unique elements.
+   * @param outIdx
+   * @return a new instance of Unique
    */
-  public Constant<TFloat32> val(Shape shape, FloatDataBuffer data) {
-    return Constant.tensorOf(scope, shape, data);
+  public <T extends TType, V extends TNumber, U extends TNumber> Unique<T, V> unique(Operand<T> x,
+      Operand<U> axis, DataType<V> outIdx) {
+    return Unique.create(scope, x, axis, outIdx);
   }
 
   /**
-   * Create a {@link TInt32} constant with data from the given buffer.
+   * Finds unique elements along an axis of a tensor.
+   *  <p>
+   *  This operation either returns a tensor `y` containing unique elements
+   *  along the `axis` of a tensor. The returned unique elements is sorted
+   *  in the same order as they occur along `axis` in `x`.
+   *  This operation also returns a tensor `idx` and a tensor `count`
+   *  that are the same size as the number of the elements in `x` along the
+   *  `axis` dimension. The `idx` contains the index in the unique output `y`
+   *  and the `count` contains the count in the unique output `y`.
+   *  In other words, for an `1-D` tensor `x` with `axis = None:
+   *  <p>
+   *  `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
+   *  <p>
+   *  For example:
+   *  <pre>{@code
+   *  # 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]
+   *  }</pre>
+   *  For an `2-D` tensor `x` with `axis = 0`:
+   *  <pre>{@code
+   *  # tensor 'x' is [[1, 0, 0],
+   *  #                [1, 0, 0],
+   *  #                [2, 0, 0]]
+   *  y, idx, count = unique_with_counts(x, axis=0)
+   *  y ==> [[1, 0, 0],
+   *         [2, 0, 0]]
+   *  idx ==> [0, 0, 1]
+   *  count ==> [2, 1]
+   *  }</pre>
+   *  For an `2-D` tensor `x` with `axis = 1`:
+   *  <pre>{@code
+   *  # tensor 'x' is [[1, 0, 0],
+   *  #                [1, 0, 0],
+   *  #                [2, 0, 0]]
+   *  y, idx, count = unique_with_counts(x, axis=1)
+   *  y ==> [[1, 0],
+   *         [1, 0],
+   *         [2, 0]]
+   *  idx ==> [0, 1, 1]
+   *  count ==> [1, 2]
+   *  }</pre>
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param shape the tensor shape.
-   * @param data a buffer containing the tensor data.
-   * @return an integer constant
-   * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
+   * @param <T> data type for {@code y()} output
+   * @param <V> data type for {@code idx()} output
+   * @param x A `Tensor`.
+   * @param axis A `Tensor` of type `int32` (default: None). The axis of the Tensor to
+   *  find the unique elements.
+   * @return a new instance of UniqueWithCounts
    */
-  public Constant<TInt32> val(Shape shape, IntDataBuffer data) {
-    return Constant.tensorOf(scope, shape, data);
+  public <T extends TType, U extends TNumber> UniqueWithCounts<T, TInt32> uniqueWithCounts(
+      Operand<T> x, Operand<U> axis) {
+    return UniqueWithCounts.create(scope, x, axis);
   }
 
   /**
-   * Create a {@link TUint8} constant with data from the given buffer.
+   * Finds unique elements along an axis of a tensor.
+   *  <p>
+   *  This operation either returns a tensor `y` containing unique elements
+   *  along the `axis` of a tensor. The returned unique elements is sorted
+   *  in the same order as they occur along `axis` in `x`.
+   *  This operation also returns a tensor `idx` and a tensor `count`
+   *  that are the same size as the number of the elements in `x` along the
+   *  `axis` dimension. The `idx` contains the index in the unique output `y`
+   *  and the `count` contains the count in the unique output `y`.
+   *  In other words, for an `1-D` tensor `x` with `axis = None:
+   *  <p>
+   *  `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
+   *  <p>
+   *  For example:
+   *  <pre>{@code
+   *  # 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]
+   *  }</pre>
+   *  For an `2-D` tensor `x` with `axis = 0`:
+   *  <pre>{@code
+   *  # tensor 'x' is [[1, 0, 0],
+   *  #                [1, 0, 0],
+   *  #                [2, 0, 0]]
+   *  y, idx, count = unique_with_counts(x, axis=0)
+   *  y ==> [[1, 0, 0],
+   *         [2, 0, 0]]
+   *  idx ==> [0, 0, 1]
+   *  count ==> [2, 1]
+   *  }</pre>
+   *  For an `2-D` tensor `x` with `axis = 1`:
+   *  <pre>{@code
+   *  # tensor 'x' is [[1, 0, 0],
+   *  #                [1, 0, 0],
+   *  #                [2, 0, 0]]
+   *  y, idx, count = unique_with_counts(x, axis=1)
+   *  y ==> [[1, 0],
+   *         [1, 0],
+   *         [2, 0]]
+   *  idx ==> [0, 1, 1]
+   *  count ==> [1, 2]
+   *  }</pre>
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param shape the tensor shape.
-   * @param data a buffer containing the tensor data.
-   * @return a byte constant
-   * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
+   * @param <T> data type for {@code y()} output
+   * @param <V> data type for {@code idx()} output
+   * @param x A `Tensor`.
+   * @param axis A `Tensor` of type `int32` (default: None). The axis of the Tensor to
+   *  find the unique elements.
+   * @param outIdx
+   * @return a new instance of UniqueWithCounts
    */
-  public Constant<TUint8> val(Shape shape, ByteDataBuffer data) {
-    return Constant.tensorOf(scope, shape, data);
+  public <T extends TType, V extends TNumber, U extends TNumber> UniqueWithCounts<T, V> uniqueWithCounts(
+      Operand<T> x, Operand<U> axis, DataType<V> outIdx) {
+    return UniqueWithCounts.create(scope, x, axis, outIdx);
   }
 
   /**
-   * Create a {@link TBool} constant with data from the given buffer.
+   * Converts an array of flat indices into a tuple of coordinate arrays.
+   *  <p>
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param shape the tensor shape.
-   * @param data a buffer containing the tensor data.
-   * @return an boolean constant
-   * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
-   */
-  public Constant<TBool> val(Shape shape, BooleanDataBuffer data) {
-    return Constant.tensorOf(scope, shape, data);
-  }
-
-  /**
-   * Create a {@link TString} constant with data from the given buffer, using the default UTF-8
-   *  encoding.
+   *  Example:
+   *  <pre>{@code
+   *  y = tf.unravel_index(indices=[2, 5, 7], dims=[3, 3])
+   *  # 'dims' represent a hypothetical (3, 3) tensor of indices:
+   *  # [[0, 1, *2*],
+   *  #  [3, 4, *5*],
+   *  #  [6, *7*, 8]]
+   *  # For each entry from 'indices', this operation returns
+   *  # its coordinates (marked with '*'), such as
+   *  # 2 ==> (0, 2)
+   *  # 5 ==> (1, 2)
+   *  # 7 ==> (2, 1)
+   *  y ==> [[0, 1, 2], [2, 2, 1]]
+   *  }</pre>
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param shape the tensor shape.
-   * @param data a buffer containing the tensor data.
-   * @return a string constant
-   * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
+   * @compatibility(numpy) Equivalent to np.unravel_index
+   * @end_compatibility
+   * @param <T> data type for {@code output()} output
+   * @param indices An 0-D or 1-D `int` Tensor whose elements are indices into the
+   *  flattened version of an array of dimensions dims.
+   * @param dims An 1-D `int` Tensor. The shape of the array to use for unraveling
+   *  indices.
+   * @return a new instance of UnravelIndex
    */
-  public Constant<TString> val(Shape shape, DataBuffer<String> data) {
-    return Constant.tensorOf(scope, shape, data);
+  public <T extends TNumber> UnravelIndex<T> unravelIndex(Operand<T> indices, Operand<T> dims) {
+    return UnravelIndex.create(scope, indices, dims);
   }
 
   /**
-   * Create a {@link TString} constant with data from the given buffer, using the given encoding.
+   * Unpacks a given dimension of a rank-`R` tensor into `num` rank-`(R-1)` tensors.
+   *  <p>
+   *  Unpacks `num` tensors from `value` by chipping it along the `axis` dimension.
+   *  For example, given a tensor of shape `(A, B, C, D)`;
+   *  <p>
+   *  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`).
+   *  <p>
+   *  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.
+   *  <p>
+   *  This is the opposite of `pack`.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param charset charset used to encode/decode string bytes.
-   * @param shape the tensor shape.
-   * @param data a buffer containing the tensor data.
-   * @return a string constant
-   * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
+   * @param <T> data type for {@code output()} output
+   * @param value 1-D or higher, with `axis` dimension size equal to `num`.
+   * @param num
+   * @param options carries optional attributes values
+   * @return a new instance of Unstack
    */
-  public Constant<TString> val(Charset charset, Shape shape, DataBuffer<String> data) {
-    return Constant.tensorOf(scope, charset, shape, data);
+  public <T extends TType> Unstack<T> unstack(Operand<T> value, Long num,
+      Unstack.Options... options) {
+    return Unstack.create(scope, value, num, options);
   }
 
   /**
-   * Create a constant with data from the given buffer.
+   * Op is similar to a lightweight Dequeue.
+   *  <p>
+   *  The basic functionality is similar to dequeue with many fewer
+   *  capabilities and options.  This Op is optimized for performance.
    *
-   * @param scope is a scope used to add the underlying operation.
-   * @param type the tensor datatype.
-   * @param shape the tensor shape.
-   * @param data a buffer containing the tensor data.
-   * @return a constant of type `type`
-   * @throws IllegalArgumentException If the tensor datatype or shape is not compatible with the
-   *      buffer
+   * @param dtypes
+   * @param options carries optional attributes values
+   * @return a new instance of Unstage
    */
-  public <T extends TType> Constant<T> val(DataType<T> type, Shape shape, ByteDataBuffer data) {
-    return Constant.tensorOf(scope, type, shape, data);
+  public Unstage unstage(List<DataType<?>> dtypes, Unstage.Options... options) {
+    return Unstage.create(scope, dtypes, options);
   }
 
   /**
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Operand.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Operand.java
index 8b75cf57a39..c9760b8e9c4 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Operand.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Operand.java
@@ -35,7 +35,7 @@
  *
  * // The "split" operation can be used as operand list to the "concat" operation
  * Iterable<? extends Operand<TFloat32>> split = tf.split(...);
- * tf.concat(split, tf.val(0));
+ * tf.concat(split, tf.constant(0));
  * }</pre>
  */
 public interface Operand<T extends TType> {
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Tensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Tensor.java
index 67c2eb30b13..ec2bf3857ac 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Tensor.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Tensor.java
@@ -255,7 +255,7 @@ public Shape shape() {
    *   });
    *   assertEquals(NdArrays.vectorOf(3.0f, 4.0f), data.getFloat(1));
    *
-   *   Constant<TFloat32> c = tf.val(t);
+   *   Constant<TFloat32> c = tf.constant(t);
    *   assertEquals(4.0f, c.data().getFloat(1, 1));
    * }
    * }</pre>
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Constant.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Constant.java
index ba6e40f59df..fa4e489452d 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Constant.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Constant.java
@@ -54,14 +54,14 @@
 /**
  * An operator producing a constant value.
  *
- * <p>All endpoints of this operator are named `val`, except those accepting vararg
+ * <p>All endpoints of this operator are named `constant`, except those accepting vararg
  * elements in parameter, which are named `array`. For example:
  *
  * <pre>{@code
  * Ops tf = Ops.create();
- * tf.val(1.0f);  // mapped to Constant.scalarOf(scope, float);
- * tf.val(new float[] {1.0f, 2.0f});  // mapped to Constant.vectorOf(scope, float[])
- * tf.val(new float[][] { {1.0f, 2.0f}, {3.0f, 4.0f} });  //mapped to Constant.tensorOf(scope, float[][])
+ * tf.constant(1.0f);  // mapped to Constant.scalarOf(scope, float);
+ * tf.constant(new float[] {1.0f, 2.0f});  // mapped to Constant.vectorOf(scope, float[])
+ * tf.constant(new float[][] { {1.0f, 2.0f}, {3.0f, 4.0f} });  //mapped to Constant.tensorOf(scope, float[][])
  * tf.array(1.0f, 2.0f, 3.0f);  // mapped to Constant.arrayOf(scope, float...)
  * }</pre>
  */
@@ -75,7 +75,7 @@ public final class Constant<T extends TType> extends PrimitiveOp implements Oper
    * @param data The value to put into the new constant.
    * @return an integer constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt32> scalarOf(Scope scope, int data) {
     try (Tensor<TInt32> value = TInt32.scalarOf(data)) {
       return create(scope, value);
@@ -90,7 +90,7 @@ public static Constant<TInt32> scalarOf(Scope scope, int data) {
    *     new constant will match those of the array.
    * @return an integer constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt32> vectorOf(Scope scope, int[] data) {
     try (Tensor<TInt32> value = TInt32.vectorOf(data)) {
       return create(scope, value);
@@ -120,7 +120,7 @@ public static Constant<TInt32> arrayOf(Scope scope, int... data) {
    *     new constant will match those of the array.
    * @return an integer constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt32> tensorOf(Scope scope, int[][] data) {
     try (Tensor<TInt32> value = TInt32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -135,7 +135,7 @@ public static Constant<TInt32> tensorOf(Scope scope, int[][] data) {
    *     new constant will match those of the array.
    * @return an integer constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt32> tensorOf(Scope scope, int[][][] data) {
     try (Tensor<TInt32> value = TInt32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -150,7 +150,7 @@ public static Constant<TInt32> tensorOf(Scope scope, int[][][] data) {
    *     new constant will match those of the array.
    * @return an integer constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt32> tensorOf(Scope scope, int[][][][] data) {
     try (Tensor<TInt32> value = TInt32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -165,7 +165,7 @@ public static Constant<TInt32> tensorOf(Scope scope, int[][][][] data) {
    *     new constant will match those of the array.
    * @return an integer constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt32> tensorOf(Scope scope, int[][][][][] data) {
     try (Tensor<TInt32> value = TInt32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -180,7 +180,7 @@ public static Constant<TInt32> tensorOf(Scope scope, int[][][][][] data) {
    *     new constant will match those of the array.
    * @return an integer constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt32> tensorOf(Scope scope, int[][][][][][] data) {
     try (Tensor<TInt32> value = TInt32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -194,7 +194,7 @@ public static Constant<TInt32> tensorOf(Scope scope, int[][][][][][] data) {
    * @param data an n-dimensional array of {@code int} elements.
    * @return an integer constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt32> tensorOf(Scope scope, IntNdArray data) {
     try (Tensor<TInt32> value = TInt32.tensorOf(data)) {
       return create(scope, value);
@@ -210,7 +210,7 @@ public static Constant<TInt32> tensorOf(Scope scope, IntNdArray data) {
    * @return an integer constant
    * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt32> tensorOf(Scope scope, Shape shape, IntDataBuffer data) {
     try (Tensor<TInt32> value = TInt32.tensorOf(shape, data)) {
       return create(scope, value);
@@ -224,7 +224,7 @@ public static Constant<TInt32> tensorOf(Scope scope, Shape shape, IntDataBuffer
    * @param data The value to put into the new constant.
    * @return a float constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat32> scalarOf(Scope scope, float data) {
     try (Tensor<TFloat32> value = TFloat32.scalarOf(data)) {
       return create(scope, value);
@@ -239,7 +239,7 @@ public static Constant<TFloat32> scalarOf(Scope scope, float data) {
    *     new constant will match those of the array.
    * @return a float constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat32> vectorOf(Scope scope, float[] data) {
     try (Tensor<TFloat32> value = TFloat32.vectorOf(data)) {
       return create(scope, value);
@@ -269,7 +269,7 @@ public static Constant<TFloat32> arrayOf(Scope scope, float... data) {
    *     new constant will match those of the array.
    * @return a float constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat32> tensorOf(Scope scope, float[][] data) {
     try (Tensor<TFloat32> value = TFloat32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -284,7 +284,7 @@ public static Constant<TFloat32> tensorOf(Scope scope, float[][] data) {
    *     new constant will match those of the array.
    * @return a float constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat32> tensorOf(Scope scope, float[][][] data) {
     try (Tensor<TFloat32> value = TFloat32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -299,7 +299,7 @@ public static Constant<TFloat32> tensorOf(Scope scope, float[][][] data) {
    *     new constant will match those of the array.
    * @return a float constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat32> tensorOf(Scope scope, float[][][][] data) {
     try (Tensor<TFloat32> value = TFloat32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -314,7 +314,7 @@ public static Constant<TFloat32> tensorOf(Scope scope, float[][][][] data) {
    *     new constant will match those of the array.
    * @return a float constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat32> tensorOf(Scope scope, float[][][][][] data) {
     try (Tensor<TFloat32> value = TFloat32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -329,7 +329,7 @@ public static Constant<TFloat32> tensorOf(Scope scope, float[][][][][] data) {
    *     new constant will match those of the array.
    * @return a float constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat32> tensorOf(Scope scope, float[][][][][][] data) {
     try (Tensor<TFloat32> value = TFloat32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -343,7 +343,7 @@ public static Constant<TFloat32> tensorOf(Scope scope, float[][][][][][] data) {
    * @param data an n-dimensional array of {@code float} elements.
    * @return a float constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat32> tensorOf(Scope scope, FloatNdArray data) {
     try (Tensor<TFloat32> value = TFloat32.tensorOf(data)) {
       return create(scope, value);
@@ -359,7 +359,7 @@ public static Constant<TFloat32> tensorOf(Scope scope, FloatNdArray data) {
    * @return a float constant
    * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat32> tensorOf(Scope scope, Shape shape, FloatDataBuffer data) {
     try (Tensor<TFloat32> value = TFloat32.tensorOf(shape, data)) {
       return create(scope, value);
@@ -373,7 +373,7 @@ public static Constant<TFloat32> tensorOf(Scope scope, Shape shape, FloatDataBuf
    * @param data The value to put into the new constant.
    * @return a double constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat64> scalarOf(Scope scope, double data) {
     try (Tensor<TFloat64> value = TFloat64.scalarOf(data)) {
       return create(scope, value);
@@ -388,7 +388,7 @@ public static Constant<TFloat64> scalarOf(Scope scope, double data) {
    *     new constant will match those of the array.
    * @return a double constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat64> vectorOf(Scope scope, double[] data) {
     try (Tensor<TFloat64> value = TFloat64.vectorOf(data)) {
       return create(scope, value);
@@ -418,7 +418,7 @@ public static Constant<TFloat64> arrayOf(Scope scope, double... data) {
    *     new constant will match those of the array.
    * @return a double constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat64> tensorOf(Scope scope, double[][] data) {
     try (Tensor<TFloat64> value = TFloat64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -433,7 +433,7 @@ public static Constant<TFloat64> tensorOf(Scope scope, double[][] data) {
    *     new constant will match those of the array.
    * @return a double constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat64> tensorOf(Scope scope, double[][][] data) {
     try (Tensor<TFloat64> value = TFloat64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -448,7 +448,7 @@ public static Constant<TFloat64> tensorOf(Scope scope, double[][][] data) {
    *     new constant will match those of the array.
    * @return a double constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat64> tensorOf(Scope scope, double[][][][] data) {
     try (Tensor<TFloat64> value = TFloat64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -463,7 +463,7 @@ public static Constant<TFloat64> tensorOf(Scope scope, double[][][][] data) {
    *     new constant will match those of the array.
    * @return a double constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat64> tensorOf(Scope scope, double[][][][][] data) {
     try (Tensor<TFloat64> value = TFloat64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -478,7 +478,7 @@ public static Constant<TFloat64> tensorOf(Scope scope, double[][][][][] data) {
    *     new constant will match those of the array.
    * @return a double constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat64> tensorOf(Scope scope, double[][][][][][] data) {
     try (Tensor<TFloat64> value = TFloat64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -492,7 +492,7 @@ public static Constant<TFloat64> tensorOf(Scope scope, double[][][][][][] data)
    * @param data an n-dimensional array of {@code double} elements.
    * @return a double constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat64> tensorOf(Scope scope, DoubleNdArray data) {
     try (Tensor<TFloat64> value = TFloat64.tensorOf(data)) {
       return create(scope, value);
@@ -508,7 +508,7 @@ public static Constant<TFloat64> tensorOf(Scope scope, DoubleNdArray data) {
    * @return a double constant
    * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TFloat64> tensorOf(Scope scope, Shape shape, DoubleDataBuffer data) {
     try (Tensor<TFloat64> value = TFloat64.tensorOf(shape, data)) {
       return create(scope, value);
@@ -522,7 +522,7 @@ public static Constant<TFloat64> tensorOf(Scope scope, Shape shape, DoubleDataBu
    * @param data The value to put into the new constant.
    * @return a long constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt64> scalarOf(Scope scope, long data) {
     try (Tensor<TInt64> value = TInt64.scalarOf(data)) {
       return create(scope, value);
@@ -537,7 +537,7 @@ public static Constant<TInt64> scalarOf(Scope scope, long data) {
    *     new constant will match those of the array.
    * @return a long constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt64> vectorOf(Scope scope, long[] data) {
     try (Tensor<TInt64> value = TInt64.vectorOf(data)) {
       return create(scope, value);
@@ -552,7 +552,7 @@ public static Constant<TInt64> vectorOf(Scope scope, long[] data) {
    *     new constant will match those of the array.
    * @return a long constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt64> tensorOf(Scope scope, long[][] data) {
     try (Tensor<TInt64> value = TInt64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -582,7 +582,7 @@ public static Constant<TInt64> arrayOf(Scope scope, long... data) {
    *     new constant will match those of the array.
    * @return a long constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt64> tensorOf(Scope scope, long[][][] data) {
     try (Tensor<TInt64> value = TInt64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -597,7 +597,7 @@ public static Constant<TInt64> tensorOf(Scope scope, long[][][] data) {
    *     new constant will match those of the array.
    * @return a long constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt64> tensorOf(Scope scope, long[][][][] data) {
     try (Tensor<TInt64> value = TInt64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -612,7 +612,7 @@ public static Constant<TInt64> tensorOf(Scope scope, long[][][][] data) {
    *     new constant will match those of the array.
    * @return a long constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt64> tensorOf(Scope scope, long[][][][][] data) {
     try (Tensor<TInt64> value = TInt64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -627,7 +627,7 @@ public static Constant<TInt64> tensorOf(Scope scope, long[][][][][] data) {
    *     new constant will match those of the array.
    * @return a long constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt64> tensorOf(Scope scope, long[][][][][][] data) {
     try (Tensor<TInt64> value = TInt64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -641,7 +641,7 @@ public static Constant<TInt64> tensorOf(Scope scope, long[][][][][][] data) {
    * @param data an n-dimensional array of {@code long} elements.
    * @return a long constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt64> tensorOf(Scope scope, LongNdArray data) {
     try (Tensor<TInt64> value = TInt64.tensorOf(data)) {
       return create(scope, value);
@@ -657,7 +657,7 @@ public static Constant<TInt64> tensorOf(Scope scope, LongNdArray data) {
    * @return a long constant
    * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt64> tensorOf(Scope scope, Shape shape, LongDataBuffer data) {
     try (Tensor<TInt64> value = TInt64.tensorOf(shape, data)) {
       return create(scope, value);
@@ -671,7 +671,7 @@ public static Constant<TInt64> tensorOf(Scope scope, Shape shape, LongDataBuffer
    * @param data The value to put into the new constant.
    * @return a boolean constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TBool> scalarOf(Scope scope, boolean data) {
     try (Tensor<TBool> value = TBool.scalarOf(data)) {
       return create(scope, value);
@@ -686,7 +686,7 @@ public static Constant<TBool> scalarOf(Scope scope, boolean data) {
    *     new constant will match those of the array.
    * @return a boolean constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TBool> vectorOf(Scope scope, boolean[] data) {
     try (Tensor<TBool> value = TBool.vectorOf(data)) {
       return create(scope, value);
@@ -716,7 +716,7 @@ public static Constant<TBool> arrayOf(Scope scope, boolean... data) {
    *     new constant will match those of the array.
    * @return a boolean constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TBool> tensorOf(Scope scope, boolean[][] data) {
     try (Tensor<TBool> value = TBool.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -731,7 +731,7 @@ public static Constant<TBool> tensorOf(Scope scope, boolean[][] data) {
    *     new constant will match those of the array.
    * @return a boolean constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TBool> tensorOf(Scope scope, boolean[][][] data) {
     try (Tensor<TBool> value = TBool.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -746,7 +746,7 @@ public static Constant<TBool> tensorOf(Scope scope, boolean[][][] data) {
    *     new constant will match those of the array.
    * @return a boolean constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TBool> tensorOf(Scope scope, boolean[][][][] data) {
     try (Tensor<TBool> value = TBool.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -761,7 +761,7 @@ public static Constant<TBool> tensorOf(Scope scope, boolean[][][][] data) {
    *     new constant will match those of the array.
    * @return a boolean constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TBool> tensorOf(Scope scope, boolean[][][][][] data) {
     try (Tensor<TBool> value = TBool.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -776,7 +776,7 @@ public static Constant<TBool> tensorOf(Scope scope, boolean[][][][][] data) {
    *     new constant will match those of the array.
    * @return a boolean constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TBool> tensorOf(Scope scope, boolean[][][][][][] data) {
     try (Tensor<TBool> value = TBool.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(t, data))) {
       return create(scope, value);
@@ -790,7 +790,7 @@ public static Constant<TBool> tensorOf(Scope scope, boolean[][][][][][] data) {
    * @param data an n-dimensional array of {@code boolean} elements.
    * @return a boolean constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TBool> tensorOf(Scope scope, BooleanNdArray data) {
     try (Tensor<TBool> value = TBool.tensorOf(data)) {
       return create(scope, value);
@@ -806,7 +806,7 @@ public static Constant<TBool> tensorOf(Scope scope, BooleanNdArray data) {
    * @return an boolean constant
    * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TBool> tensorOf(Scope scope, Shape shape, BooleanDataBuffer data) {
     try (Tensor<TBool> value = TBool.tensorOf(shape, data)) {
       return create(scope, value);
@@ -820,7 +820,7 @@ public static Constant<TBool> tensorOf(Scope scope, Shape shape, BooleanDataBuff
    * @param data The value to put into the new constant.
    * @return a byte constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TUint8> scalarOf(Scope scope, byte data) {
     try (Tensor<TUint8> value = TUint8.scalarOf(data)) {
       return create(scope, value);
@@ -835,7 +835,7 @@ public static Constant<TUint8> scalarOf(Scope scope, byte data) {
    *     new constant will match those of the array.
    * @return a byte constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TUint8> vectorOf(Scope scope, byte[] data) {
     try (Tensor<TUint8> value = TUint8.vectorOf(data)) {
       return create(scope, value);
@@ -865,7 +865,7 @@ public static Constant<TUint8> arrayOf(Scope scope, byte... data) {
    *     new constant will match those of the array.
    * @return a byte constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TUint8> tensorOf(Scope scope, byte[][] data) {
     try (Tensor<TUint8> value = TUint8.tensorOf(StdArrays.shapeOf(data), d -> StdArrays.copyTo(d, data))) {
       return create(scope, value);
@@ -880,7 +880,7 @@ public static Constant<TUint8> tensorOf(Scope scope, byte[][] data) {
    *     new constant will match those of the array.
    * @return a byte constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TUint8> tensorOf(Scope scope, byte[][][] data) {
     try (Tensor<TUint8> value = TUint8.tensorOf(StdArrays.shapeOf(data), d -> StdArrays.copyTo(d, data))) {
       return create(scope, value);
@@ -895,7 +895,7 @@ public static Constant<TUint8> tensorOf(Scope scope, byte[][][] data) {
    *     new constant will match those of the array.
    * @return a byte constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TUint8> tensorOf(Scope scope, byte[][][][] data) {
     try (Tensor<TUint8> value = TUint8.tensorOf(StdArrays.shapeOf(data), d -> StdArrays.copyTo(d, data))) {
       return create(scope, value);
@@ -910,7 +910,7 @@ public static Constant<TUint8> tensorOf(Scope scope, byte[][][][] data) {
    *     new constant will match those of the array.
    * @return a byte constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TUint8> tensorOf(Scope scope, byte[][][][][] data) {
     try (Tensor<TUint8> value = TUint8.tensorOf(StdArrays.shapeOf(data), d -> StdArrays.copyTo(d, data))) {
       return create(scope, value);
@@ -925,7 +925,7 @@ public static Constant<TUint8> tensorOf(Scope scope, byte[][][][][] data) {
    *     new constant will match those of the array.
    * @return a byte constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TUint8> tensorOf(Scope scope, byte[][][][][][] data) {
     try (Tensor<TUint8> value = TUint8.tensorOf(StdArrays.shapeOf(data), d -> StdArrays.copyTo(d, data))) {
       return create(scope, value);
@@ -939,7 +939,7 @@ public static Constant<TUint8> tensorOf(Scope scope, byte[][][][][][] data) {
    * @param data an n-dimensional array of {@code byte} elements.
    * @return a byte constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TUint8> tensorOf(Scope scope, ByteNdArray data) {
     try (Tensor<TUint8> value = TUint8.tensorOf(data)) {
       return create(scope, value);
@@ -955,7 +955,7 @@ public static Constant<TUint8> tensorOf(Scope scope, ByteNdArray data) {
    * @return a byte constant
    * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TUint8> tensorOf(Scope scope, Shape shape, ByteDataBuffer data) {
     try (Tensor<TUint8> value = TUint8.tensorOf(shape, data)) {
       return create(scope, value);
@@ -973,7 +973,7 @@ public static Constant<TUint8> tensorOf(Scope scope, Shape shape, ByteDataBuffer
    * @throws IllegalArgumentException If the tensor datatype or shape is not compatible with the
    *     buffer
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static <T extends TType> Constant<T> tensorOf(Scope scope, DataType<T> type, Shape shape,
       ByteDataBuffer data) {
     try (Tensor<T> value = Tensor.of(type, shape, data)) {
@@ -988,7 +988,7 @@ public static <T extends TType> Constant<T> tensorOf(Scope scope, DataType<T> ty
    * @param data The string to put into the new constant.
    * @return a string constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TString> scalarOf(Scope scope, String data) {
     try (Tensor<TString> value = TString.scalarOf(data)) {
       return create(scope, value);
@@ -1003,7 +1003,7 @@ public static Constant<TString> scalarOf(Scope scope, String data) {
    * @param data The string to put into the new constant.
    * @return a string constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TString> scalarOf(Scope scope, Charset charset, String data) {
     try (Tensor<TString> value = TString.tensorOf(charset, NdArrays.scalarOfObject(data))) {
       return create(scope, value);
@@ -1033,7 +1033,7 @@ public static Constant<TString> vectorOf(Scope scope, String[] data) {
    *     sequences of bytes from the last array dimension.
    * @return the {@code String} constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TString> vectorOf(Scope scope, Charset charset, String[] data) {
     try (Tensor<TString> value = TString.tensorOf(charset, NdArrays.vectorOfObjects(data))) {
       return Constant.create(scope, value);
@@ -1155,7 +1155,7 @@ public static Constant<TString> tensorOf(Scope scope, String[][][][][][] data) {
    * @param data an n-dimensional array of {@code String} elements.
    * @return a string constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TString> tensorOf(Scope scope, NdArray<String> data) {
     try (Tensor<TString> value = TString.tensorOf(data)) {
       return create(scope, value);
@@ -1171,7 +1171,7 @@ public static Constant<TString> tensorOf(Scope scope, NdArray<String> data) {
    * @param data an n-dimensional array of {@code String} elements.
    * @return a string constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TString> tensorOf(Scope scope, Charset charset, NdArray<String> data) {
     try (Tensor<TString> value = TString.tensorOf(charset, data)) {
       return create(scope, value);
@@ -1188,7 +1188,7 @@ public static Constant<TString> tensorOf(Scope scope, Charset charset, NdArray<S
    * @return a string constant
    * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TString> tensorOf(Scope scope, Shape shape, DataBuffer<String> data) {
     try (Tensor<TString> value = TString.tensorOf(shape, data)) {
       return create(scope, value);
@@ -1205,7 +1205,7 @@ public static Constant<TString> tensorOf(Scope scope, Shape shape, DataBuffer<St
    * @return a string constant
    * @throws IllegalArgumentException If the tensor shape is not compatible with the buffer
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TString> tensorOf(Scope scope, Charset charset, Shape shape,
       DataBuffer<String> data) {
     try (Tensor<TString> value = TString.tensorOf(charset, shape, data)) {
@@ -1221,7 +1221,7 @@ public static Constant<TString> tensorOf(Scope scope, Charset charset, Shape sha
    * @param shape a shape
    * @return a long constant
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static Constant<TInt64> tensorOf(Scope scope, Shape shape) {
     return vectorOf(scope, shape.asArray());
   }
@@ -1233,7 +1233,7 @@ public static Constant<TInt64> tensorOf(Scope scope, Shape shape) {
    * @param tensor a Tensor holding the constant value
    * @return a constant of the same data type as `tensor`
    */
-  @Endpoint(name = "val")
+  @Endpoint
   public static <T extends TType> Constant<T> create(Scope scope, Tensor<T> tensor) {
     return new Constant<>(
         scope
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Gradients.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Gradients.java
index 8de2193fd4f..cd71be8f032 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Gradients.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Gradients.java
@@ -44,7 +44,7 @@
  * Example of usage:
  * <pre>{@code
  * Gradients gradients = tf.gradients(loss, Arrays.asList(w, b));
- * Constant<TFloat32> alpha = tf.val(1.0f);
+ * Constant<TFloat32> alpha = tf.constant(1.0f);
  * tf.train.applyGradientDescent(w, alpha, gradients.<Float>dy(0));
  * tf.train.applyGradientDescent(b, alpha, gradients.<Float>dy(1));
  * }</pre>
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Zeros.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Zeros.java
index eae41cb12da..217d590e6c3 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Zeros.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Zeros.java
@@ -30,9 +30,9 @@
  * An operator creating a constant initialized with zeros of the shape given by `dims`.
  * 
  * <p>For example, the following expression
- * <pre>{@code tf.zeros(tf.val(shape), TFloat32.DTYPE)</pre>
+ * <pre>{@code tf.zeros(tf.constant(shape), TFloat32.DTYPE)</pre>
  * is the equivalent of
- * <pre>{@code tf.fill(tf.val(shape), tf.val(0.0f))</pre>
+ * <pre>{@code tf.fill(tf.constant(shape), tf.constant(0.0f))</pre>
  *
  * @param <T> constant type
  */
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/EagerOperationBuilderTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/EagerOperationBuilderTest.java
index 68531816984..cdaf66f1160 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/EagerOperationBuilderTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/EagerOperationBuilderTest.java
@@ -61,8 +61,8 @@ public void addInputs() {
       Ops tf = Ops.create(session);
       Operation asrt =
           opBuilder(session, "Assert", "assert")
-              .addInput(tf.val(true).asOutput())
-              .addInputList(new Output<?>[] {tf.val(-1).asOutput()})
+              .addInput(tf.constant(true).asOutput())
+              .addInputList(new Output<?>[] {tf.constant(-1).asOutput()})
               .build();
       try {
         opBuilder(session, "Const", "var").addControlInput(asrt);
@@ -79,8 +79,8 @@ public void setDevice() {
       Ops tf = Ops.create(session);
       opBuilder(session, "Add", "SetDevice")
           .setDevice("/job:localhost/replica:0/task:0/device:CPU:0")
-          .addInput(tf.val(2).asOutput())
-          .addInput(tf.val(4).asOutput())
+          .addInput(tf.constant(2).asOutput())
+          .addInput(tf.constant(4).asOutput())
           .build();
     }
   }
@@ -110,19 +110,19 @@ public void setAttrs() {
           .build();
       // list(int), string
       opBuilder(session, "MaxPool", "IntListAndString")
-          .addInput(tf.val(new float[2][2][2][2]).asOutput())
+          .addInput(tf.constant(new float[2][2][2][2]).asOutput())
           .setAttr("ksize", new long[] {1, 1, 1, 1})
           .setAttr("strides", new long[] {1, 1, 1, 1})
           .setAttr("padding", "SAME")
           .build();
       // list(float), device
       opBuilder(session, "FractionalMaxPool", "FloatList")
-          .addInput(tf.val(new float[2][2][2][2]).asOutput())
+          .addInput(tf.constant(new float[2][2][2][2]).asOutput())
           .setAttr("pooling_ratio", new float[] {1.0f, 1.44f, 1.73f, 1.0f})
           .build();
       // shape
       opBuilder(session, "EnsureShape", "ShapeAttr")
-          .addInput(tf.val(new int[2][2]).asOutput())
+          .addInput(tf.constant(new int[2][2]).asOutput())
           .setAttr("shape", Shape.of(2, 2))
           .build();
       // list(shape)
@@ -132,14 +132,14 @@ public void setAttrs() {
           .build();
       // bool
       opBuilder(session, "All", "Bool")
-          .addInput(tf.val(new boolean[] {true, true, false}).asOutput())
-          .addInput(tf.val(0).asOutput())
+          .addInput(tf.constant(new boolean[] {true, true, false}).asOutput())
+          .addInput(tf.constant(0).asOutput())
           .setAttr("keep_dims", false)
           .build();
       // float
       opBuilder(session, "ApproximateEqual", "Float")
-          .addInput(tf.val(10.00001f).asOutput())
-          .addInput(tf.val(10.00000f).asOutput())
+          .addInput(tf.constant(10.00001f).asOutput())
+          .addInput(tf.constant(10.00000f).asOutput())
           .setAttr("tolerance", 0.1f)
           .build();
       // Missing tests: list(string), list(byte), list(bool), list(type)
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/EagerOperationTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/EagerOperationTest.java
index cd215f9c606..07b43513285 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/EagerOperationTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/EagerOperationTest.java
@@ -63,8 +63,8 @@ public void outputTensor() {
       Ops tf = Ops.create(session);
       EagerOperation add =
           opBuilder(session, "Add", "CompareResult")
-              .addInput(tf.val(2).asOutput())
-              .addInput(tf.val(4).asOutput())
+              .addInput(tf.constant(2).asOutput())
+              .addInput(tf.constant(4).asOutput())
               .build();
       assertEquals(6, add.tensor(0).expect(TInt32.DTYPE).data().getInt());
 
@@ -79,8 +79,8 @@ public void outputTensor() {
   public void inputAndOutputListLengths() {
     try (EagerSession session = EagerSession.create()) {
       Ops tf = Ops.create(session);
-      Output<TFloat32> c1 = tf.val(new float[] {1f, 2f}).asOutput();
-      Output<TFloat32> c2 = tf.val(new float[] {3f, 4f}).asOutput();
+      Output<TFloat32> c1 = tf.constant(new float[] {1f, 2f}).asOutput();
+      Output<TFloat32> c2 = tf.constant(new float[] {3f, 4f}).asOutput();
 
       EagerOperation acc =
           opBuilder(session, "AddN", "InputListLength")
@@ -91,7 +91,7 @@ public void inputAndOutputListLengths() {
 
       EagerOperation split =
           opBuilder(session, "Split", "OutputListLength")
-              .addInput(tf.val(0).asOutput())
+              .addInput(tf.constant(0).asOutput())
               .addInput(c1)
               .setAttr("num_split", 2)
               .build();
@@ -120,8 +120,8 @@ public void numOutputs() {
       Ops tf = Ops.create(session);
       EagerOperation op =
           opBuilder(session, "UniqueWithCountsV2", "unq")
-              .addInput(tf.val(new int[] {1, 2, 1}).asOutput())
-              .addInput(tf.val(new int[] {0}).asOutput())
+              .addInput(tf.constant(new int[] {1, 2, 1}).asOutput())
+              .addInput(tf.constant(new int[] {0}).asOutput())
               .setAttr("out_idx", TInt32.DTYPE)
               .build();
       assertEquals(3, op.numOutputs());
@@ -134,8 +134,8 @@ public void opNotAccessibleIfSessionIsClosed() {
     Ops tf = Ops.create(session);
     EagerOperation add =
         opBuilder(session, "Add", "SessionClosed")
-            .addInput(tf.val(2).asOutput())
-            .addInput(tf.val(4).asOutput())
+            .addInput(tf.constant(2).asOutput())
+            .addInput(tf.constant(4).asOutput())
             .build();
     assertEquals(1, add.outputListLength("z"));
     session.close();
@@ -153,8 +153,8 @@ public void outputIndexOutOfBounds() {
       Ops tf = Ops.create(session);
       EagerOperation add =
           opBuilder(session, "Add", "OutOfRange")
-              .addInput(tf.val(2).asOutput())
-              .addInput(tf.val(4).asOutput())
+              .addInput(tf.constant(2).asOutput())
+              .addInput(tf.constant(4).asOutput())
               .build();
       try {
         add.getUnsafeNativeHandle(1);
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/GraphOperationBuilderTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/GraphOperationBuilderTest.java
index 85d850308d7..bb288549031 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/GraphOperationBuilderTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/GraphOperationBuilderTest.java
@@ -38,7 +38,7 @@ public void failWhenMixingOperationsOnDifferentGraphs() {
     try (Graph g1 = new Graph();
         Graph g2 = new Graph()) {
       Ops tf = Ops.create(g1);
-      Constant<TInt32> c1 = tf.val(3);
+      Constant<TInt32> c1 = tf.constant(3);
       tf.math.add(c1, c1);
       try {
         Ops tf2 = Ops.create(g2);
@@ -113,7 +113,7 @@ public void setAttr() {
       assertTrue(hasNode(g, "Int"));
       // list(int)
       g.opBuilder("MaxPool", "IntList")
-          .addInput(tf.val(new float[2][2][2][2]).asOutput())
+          .addInput(tf.constant(new float[2][2][2][2]).asOutput())
           .setAttr("ksize", new long[] {1, 1, 1, 1})
           .setAttr("strides", new long[] {1, 1, 1, 1})
           .setAttr("padding", "SAME")
@@ -121,7 +121,7 @@ public void setAttr() {
       assertTrue(hasNode(g, "IntList"));
       // list(float)
       g.opBuilder("FractionalMaxPool", "FloatList")
-          .addInput(tf.val(new float[2][2][2][2]).asOutput())
+          .addInput(tf.constant(new float[2][2][2][2]).asOutput())
           .setAttr("pooling_ratio", new float[] {1.0f, 1.44f, 1.73f, 1.0f})
           .build();
       assertTrue(hasNode(g, "FloatList"));
@@ -207,8 +207,8 @@ private static void testSetAttrShapeList(Shape[] shapes) {
               .build()
               .output(0);
       assertTrue(hasNode(g, "queue"));
-      Output<TInt32> c1 = tf.val(matrix).asOutput();
-      Output<TInt32> c2 = tf.val(new int[][][] {matrix, matrix}).asOutput();
+      Output<TInt32> c1 = tf.constant(matrix).asOutput();
+      Output<TInt32> c2 = tf.constant(new int[][][] {matrix, matrix}).asOutput();
       Operation enqueue =
           g.opBuilder("QueueEnqueue", "enqueue")
               .addInput(queue)
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/GraphOperationTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/GraphOperationTest.java
index f4c624145e4..7606d70e127 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/GraphOperationTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/GraphOperationTest.java
@@ -38,7 +38,7 @@ public class GraphOperationTest {
   public void outputListLengthFailsOnInvalidName() {
     try (Graph g = new Graph()) {
       Ops tf = Ops.create(g);
-      Operation op = tf.math.add(tf.val(1), tf.val(2)).op();
+      Operation op = tf.math.add(tf.constant(1), tf.constant(2)).op();
       assertEquals(1, op.outputListLength("z"));
 
       try {
@@ -55,8 +55,8 @@ public void operationEquality() {
     GraphOperation op1;
     try (Graph g = new Graph()) {
       Ops tf = Ops.create(g);
-      op1 = (GraphOperation)tf.withName("op1").val(1).op();
-      GraphOperation op2 = (GraphOperation)tf.withName("op2").val(2).op();
+      op1 = (GraphOperation)tf.withName("op1").constant(1).op();
+      GraphOperation op2 = (GraphOperation)tf.withName("op2").constant(2).op();
       GraphOperation op3 = new GraphOperation(g, op1.getUnsafeNativeHandle());
       GraphOperation op4 = g.operation("op1");
       assertEquals(op1, op1);
@@ -71,7 +71,7 @@ public void operationEquality() {
     }
     try (Graph g = new Graph()) {
       Ops tf = Ops.create(g);
-      Operation newOp1 = tf.withName("op1").val(1).op();
+      Operation newOp1 = tf.withName("op1").constant(1).op();
       assertNotEquals(op1, newOp1);
     }
   }
@@ -80,8 +80,8 @@ public void operationEquality() {
   public void operationCollection() {
     try (Graph g = new Graph()) {
       Ops tf = Ops.create(g);
-      GraphOperation op1 = (GraphOperation)tf.withName("op1").val(1).op();
-      GraphOperation op2 = (GraphOperation)tf.withName("op2").val(2).op();
+      GraphOperation op1 = (GraphOperation)tf.withName("op1").constant(1).op();
+      GraphOperation op2 = (GraphOperation)tf.withName("op2").constant(2).op();
       GraphOperation op3 = new GraphOperation(g, op1.getUnsafeNativeHandle());
       GraphOperation op4 = g.operation("op1");
       Set<Operation> ops = new HashSet<>();
@@ -107,7 +107,7 @@ public void operationToString() {
   public void outputEquality() {
     try (Graph g = new Graph()) {
       Ops tf = Ops.create(g);
-      Output<TInt32> output = tf.withName("c").val(1).asOutput();
+      Output<TInt32> output = tf.withName("c").constant(1).asOutput();
       Output<TInt32> output1 = output.op().output(0);
       Output<TInt32> output2 = g.operation("c").output(0);
       assertEquals(output, output1);
@@ -121,7 +121,7 @@ public void outputEquality() {
   public void outputCollection() {
     try (Graph g = new Graph()) {
       Ops tf = Ops.create(g);
-      Output<TInt32> output = tf.withName("c").val(1).asOutput();
+      Output<TInt32> output = tf.withName("c").constant(1).asOutput();
       Output<TInt32> output1 = output.op().output(0);
       Output<TInt32> output2 = g.operation("c").output(0);
       Set<Output<TInt32>> ops = new HashSet<>();
@@ -137,7 +137,7 @@ public void outputCollection() {
   public void outputToString() {
     try (Graph g = new Graph()) {
       Ops tf = Ops.create(g);
-      Output<TInt32> output = tf.withName("c").val(1).asOutput();
+      Output<TInt32> output = tf.withName("c").constant(1).asOutput();
       assertNotNull(output.toString());
     }
   }
@@ -146,9 +146,9 @@ public void outputToString() {
   public void outputListLength() {
     try (Graph g = new Graph()) {
       Ops tf = Ops.create(g);
-      assertEquals(1, tf.split(tf.val(0), tf.array(0, 1), 1L).op().outputListLength("output"));
-      assertEquals(2, tf.split(tf.val(0), tf.array(0, 1), 2L).op().outputListLength("output"));
-      assertEquals(3, tf.split(tf.val(0), tf.array(0, 1, 2), 3L).op().outputListLength("output"));
+      assertEquals(1, tf.split(tf.constant(0), tf.array(0, 1), 1L).op().outputListLength("output"));
+      assertEquals(2, tf.split(tf.constant(0), tf.array(0, 1), 2L).op().outputListLength("output"));
+      assertEquals(3, tf.split(tf.constant(0), tf.array(0, 1, 2), 3L).op().outputListLength("output"));
     }
   }
 
@@ -156,9 +156,9 @@ public void outputListLength() {
   public void inputListLength() {
     try (Graph g = new Graph()) {
       Ops tf = Ops.create(g);
-      assertEquals(1, tf.split(tf.val(0), tf.array(0, 1), 1L).op().inputListLength("split_dim"));
+      assertEquals(1, tf.split(tf.constant(0), tf.array(0, 1), 1L).op().inputListLength("split_dim"));
       try {
-        tf.split(tf.val(0), tf.array(0, 1), 2L).op().inputListLength("inputs");
+        tf.split(tf.constant(0), tf.array(0, 1), 2L).op().inputListLength("inputs");
       } catch (IllegalArgumentException iae) {
         // expected
       }
@@ -169,7 +169,7 @@ public void inputListLength() {
   public void outputList() {
     try (Graph g = new Graph()) {
       Ops tf = Ops.create(g);
-      Operation split = tf.split(tf.val(0), tf.array(0, 1, 2), 3L).op();
+      Operation split = tf.split(tf.constant(0), tf.array(0, 1, 2), 3L).op();
       Output<?>[] outputs = split.outputList(1, 2);
       assertNotNull(outputs);
       assertEquals(2, outputs.length);
@@ -183,7 +183,7 @@ public void outputList() {
   public void outputTensorNotSupported() {
     try (Graph g = new Graph()) {
       Ops tf = Ops.create(g);
-      Operation split = tf.split(tf.val(0), tf.array(0, 1, 2), 3L).op();
+      Operation split = tf.split(tf.constant(0), tf.array(0, 1, 2), 3L).op();
       try {
         split.output(0).tensor();
         fail();
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/GraphTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/GraphTest.java
index 2ad5afe812e..1a70cf669bb 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/GraphTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/GraphTest.java
@@ -42,7 +42,7 @@ public void graphDefRoundTrip() {
     try (Graph g = new Graph()) {
       Ops tf = Ops.create(g);
       tf.withName("Y").linalg.matMul(
-          tf.withName("A").val(new int[2][2]),
+          tf.withName("A").constant(new int[2][2]),
           tf.withName("X").placeholder(TInt32.DTYPE),
           MatMul.transposeA(true).transposeB(false)
       );
@@ -94,9 +94,9 @@ public void iterateOverOperations() {
       assertFalse(iterator.hasNext());
 
       operations = new HashSet<>();
-      operations.add(tf.withName("Const-A").val(1.0f).op());
-      operations.add(tf.withName("Const-B").val(23).op());
-      operations.add(tf.withName("Const-C").val(1.618).op());
+      operations.add(tf.withName("Const-A").constant(1.0f).op());
+      operations.add(tf.withName("Const-B").constant(23).op());
+      operations.add(tf.withName("Const-C").constant(1.618).op());
 
       iterator = g.operations();
 
@@ -283,7 +283,7 @@ public void buildWhileLoopSingleInput() {
           toArray(input),
           (condGraph, condInputs, condOutputs) -> {
             Ops tfc = Ops.create(condGraph);
-            condOutputs[0] = tfc.math.less((Output<TInt32>)condInputs[0], tfc.val(16)).z();
+            condOutputs[0] = tfc.math.less((Output<TInt32>)condInputs[0], tfc.constant(16)).z();
           },
           (bodyGraph, bodyInputs, bodyOutputs) -> {
             Ops tfb = Ops.create(bodyGraph);
@@ -318,7 +318,7 @@ public void buildWhileLoopMultipleInputs() {
           inputs,
           (condGraph, condInputs, condOutputs) -> {
             Ops tfc = Ops.create(condGraph);
-            condOutputs[0] = tfc.math.less((Output<TInt32>)condInputs[0], tfc.val(16)).z();
+            condOutputs[0] = tfc.math.less((Output<TInt32>)condInputs[0], tfc.constant(16)).z();
           },
           (bodyGraph, bodyInputs, bodyOutputs) -> {
             Ops tfb = Ops.create(bodyGraph);
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/SessionTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/SessionTest.java
index d5bce2d1a7d..0e5d499f4dc 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/SessionTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/SessionTest.java
@@ -71,7 +71,7 @@ public void runUsingColonSeparatedNames() {
     try (Graph g = new Graph();
         Session s = new Session(g)) {
       Ops tf = Ops.create(g);
-      Split<TInt32> split = tf.split(tf.val(0), tf.array(1, 2, 3, 4), 2L);
+      Split<TInt32> split = tf.split(tf.constant(0), tf.array(1, 2, 3, 4), 2L);
       tf.math.add(split.output().get(0), split.output().get(1));
 
       // Fetch using colon separated names.
@@ -130,8 +130,8 @@ public void runMultipleOutputs() {
     try (Graph g = new Graph();
         Session s = new Session(g)) {
       Ops tf = Ops.create(g);
-      tf.withName("c1").val(2718);
-      tf.withName("c2").val(31415);
+      tf.withName("c1").constant(2718);
+      tf.withName("c2").constant(31415);
       AutoCloseableList<Tensor<?>> outputs =
           new AutoCloseableList<>(s.runner().fetch("c2").fetch("c1").run());
       assertEquals(2, outputs.size());
@@ -204,7 +204,7 @@ private static byte[] singleThreadConfigProto() {
 
   private static void transpose_A_times_X(Ops tf, int[][] a) {
     tf.withName("Y").linalg.matMul(
-        tf.withName("A").val(a),
+        tf.withName("A").constant(a),
         tf.withName("X").placeholder(TInt32.DTYPE),
         MatMul.transposeA(true).transposeB(false)
     );
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/TensorTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/TensorTest.java
index 87aca1033f8..6694dbe1ba3 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/TensorTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/TensorTest.java
@@ -479,7 +479,7 @@ public void eagerTensorIsReleasedAfterSessionIsClosed() {
     Tensor<TInt32> sum;
     try (EagerSession session = EagerSession.create()) {
       Ops tf = Ops.create(session);
-      sum = tf.math.add(tf.val(10), tf.val(20)).asTensor();
+      sum = tf.math.add(tf.constant(10), tf.constant(20)).asTensor();
       sum.nativeHandle(); // does not throw
       assertEquals(30, sum.data().getInt());
     }
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/OperandsTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/OperandsTest.java
index 510c18adb4c..6a570584f33 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/OperandsTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/OperandsTest.java
@@ -33,7 +33,7 @@ public class OperandsTest {
   public void createOutputArrayFromOperandList() {
     try (Graph g = new Graph()) {
       Ops tf = Ops.create(g);
-      Split<?> split = tf.split(tf.val(0), tf.array(0, 1, 2), 3L);
+      Split<?> split = tf.split(tf.constant(0), tf.array(0, 1, 2), 3L);
       Output<?>[] array = Operands.asOutputs(split.output());
       assertEquals(split.output().size(), array.length);
       assertSame(array[0], split.output().get(0));
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/PrimitiveOpTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/PrimitiveOpTest.java
index ed92d949cd7..c0938836867 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/PrimitiveOpTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/PrimitiveOpTest.java
@@ -38,7 +38,7 @@ public void equalsHashcode() {
     try (Graph g = new Graph()) {
       Ops tf = Ops.create(g);
 
-      Output<TInt32> array = tf.val(new int[2]).asOutput();
+      Output<TInt32> array = tf.constant(new int[2]).asOutput();
 
       PrimitiveOp test1 =
           new PrimitiveOp(g.opBuilder("Shape", "shape1").addInput(array).build()) {};
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/GeneratedOperationsTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/GeneratedOperationsTest.java
index 5a7a38d2d5e..7fd3dde2071 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/GeneratedOperationsTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/GeneratedOperationsTest.java
@@ -37,7 +37,7 @@ public void tensorInputTensorOutput() {
     try (Graph g = new Graph();
         Session sess = new Session(g)) {
       Ops ops = Ops.create(g);
-      Operand<TInt32> x = ops.math.add(ops.val(1), ops.val(2));
+      Operand<TInt32> x = ops.math.add(ops.constant(1), ops.constant(2));
       try (Tensor<TInt32> result = sess.runner().fetch(x).run().get(0).expect(TInt32.DTYPE)) {
         assertEquals(3, result.data().getInt());
       }
@@ -50,9 +50,9 @@ public void testListInputTensorOutput() {
         Session sess = new Session(g)) {
       Ops ops = Ops.create(g);
       ArrayList<Operand<TInt32>> inputs = new ArrayList<>();
-      inputs.add(ops.val(1));
-      inputs.add(ops.val(2));
-      inputs.add(ops.val(3));
+      inputs.add(ops.constant(1));
+      inputs.add(ops.constant(2));
+      inputs.add(ops.constant(3));
       Operand<TInt32> x = ops.math.addN(inputs);
       try (Tensor<TInt32> result = sess.runner().fetch(x).run().get(0).expect(TInt32.DTYPE)) {
         assertEquals(6, result.data().getInt());
@@ -73,11 +73,11 @@ public void testControlDependencies() {
         Session sess = new Session(g)) {
       Ops ops = Ops.create(g);
       Operand<TInt32> variable = ops.variable(Shape.scalar(), TInt32.DTYPE);
-      Operand<?> initVariable = ops.assign(variable, ops.val(0));
+      Operand<?> initVariable = ops.assign(variable, ops.constant(0));
       ArrayList<Operand<?>> controls = new ArrayList<>();
-      controls.add(ops.assign(variable, ops.val(3)));
+      controls.add(ops.assign(variable, ops.constant(3)));
       Operand<TInt32> x =
-          ops.withControlDependencies(controls).math.add(variable, ops.val(0));
+          ops.withControlDependencies(controls).math.add(variable, ops.constant(0));
       sess.runner().addTarget(initVariable).run();
       try (Tensor<TInt32> result = sess.runner().fetch(x).run().get(0).expect(TInt32.DTYPE)) {
         assertEquals(3, result.data().getInt());
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/NumericTypesTestBase.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/NumericTypesTestBase.java
index 55c2ee3b37e..0448d367a3c 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/NumericTypesTestBase.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/NumericTypesTestBase.java
@@ -48,11 +48,11 @@ public void initializeTensorsWithZeros() {
 
       // Initialize tensor memory with zeros and take a snapshot
       tensorData.scalars().forEach(scalar -> scalar.setObject(valueOf(0)));
-      Constant<T> x = tf.val(tensor);
+      Constant<T> x = tf.constant(tensor);
 
       // Initialize the same tensor memory with ones and take a snapshot
       tensorData.scalars().forEach(scalar -> scalar.setObject(valueOf(1)));
-      Constant<T> y = tf.val(tensor);
+      Constant<T> y = tf.constant(tensor);
 
       // Subtract y from x and validate the result
       Sub<T> sub = tf.math.sub(x, y);
@@ -93,7 +93,7 @@ public void genericTest() {
         Ops tf = Ops.create(session);
 
         // Compute the power of the tensor by itself
-        Constant<TInt32> x = tf.val(tensor);
+        Constant<TInt32> x = tf.constant(tensor);
         IntNdArray result = tf.math.pow(x, x).data();
 
         // Validate result by computing the same operation in Java
diff --git a/tensorflow-core/tensorflow-core-generator/src/main/java/org/tensorflow/processor/operator/OperatorProcessor.java b/tensorflow-core/tensorflow-core-generator/src/main/java/org/tensorflow/processor/operator/OperatorProcessor.java
index 4d71b7ed978..52187ffdb88 100644
--- a/tensorflow-core/tensorflow-core-generator/src/main/java/org/tensorflow/processor/operator/OperatorProcessor.java
+++ b/tensorflow-core/tensorflow-core-generator/src/main/java/org/tensorflow/processor/operator/OperatorProcessor.java
@@ -474,13 +474,13 @@ private static TypeSpec buildTopClass(OpsSpec spec) {
                     + "  Ops tf = Ops.create(g);\n"
                     + "  // Operations are typed classes with convenience\n"
                     + "  // builders in Ops.\n"
-                    + "  Constant<TInt32> three = tf.val(3);\n"
+                    + "  Constant<TInt32> three = tf.constant(3);\n"
                     + "  // Single-result operations implement the Operand\n"
                     + "  // interface, so this works too.\n"
-                    + "  Operand<TInt32> four = tf.val(4);\n"
+                    + "  Operand<TInt32> four = tf.constant(4);\n"
                     + "  // Most builders are found within a group, and accept\n"
                     + "  // Operand types as operands\n"
-                    + "  Operand<TInt32> nine = tf.math.add(four, tf.val(5));\n"
+                    + "  Operand<TInt32> nine = tf.math.add(four, tf.constant(5));\n"
                     + "  // Multi-result operations however offer methods to\n"
                     + "  // select a particular result for use.\n"
                     + "  Operand<TInt32> result = \n"
@@ -488,10 +488,10 @@ private static TypeSpec buildTopClass(OpsSpec spec) {
                     + "  // Optional attributes\n"
                     + "  tf.linalg.matMul(a, b, MatMul.transposeA(true));\n"
                     + "  // Naming operators\n"
-                    + "  tf.withName(\"foo\").val(5); // name \"foo\"\n"
+                    + "  tf.withName(\"foo\").constant(5); // name \"foo\"\n"
                     + "  // Names can exist in a hierarchy\n"
                     + "  Ops sub = tf.withSubScope(\"sub\");\n"
-                    + "  sub.withName(\"bar\").val(4); // \"sub/bar\"\n"
+                    + "  sub.withName(\"bar\").constant(4); // \"sub/bar\"\n"
                     + "}\n"
                     + "}</pre>\n",
                 T_OP,
diff --git a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaDelta.java b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaDelta.java
index 1267a6ac001..b271993b974 100644
--- a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaDelta.java
+++ b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaDelta.java
@@ -69,10 +69,10 @@ protected void createSlots(List<Output<? extends TType>> variables) {
 
   private <T extends TType> void createAdaDeltaSlot(Output<T> v) {
     Operand<T> accumulatorInitializer = tf
-        .fill(tf.shape(v), tf.dtypes.cast(tf.val(0.0f), v.dataType()));
+        .fill(tf.shape(v), tf.dtypes.cast(tf.constant(0.0f), v.dataType()));
     createSlot(v.asOutput(), ACCUMULATOR, accumulatorInitializer);
     Operand<T> updateInitializer = tf
-        .fill(tf.shape(v), tf.dtypes.cast(tf.val(0.0f), v.dataType()));
+        .fill(tf.shape(v), tf.dtypes.cast(tf.constant(0.0f), v.dataType()));
     createSlot(v.asOutput(), ACCUMULATOR_UPDATE, updateInitializer);
   }
 
@@ -81,9 +81,9 @@ protected <T extends TType> Operand<T> applyDense(Output<T> gradient, Output<T>
     Variable<T> accumSlot = getSlot(variable, ACCUMULATOR).get();
     Variable<T> accumUpdateSlot = getSlot(variable, ACCUMULATOR_UPDATE).get();
     return tf.train.applyAdadelta(variable, accumSlot, accumUpdateSlot,
-        tf.dtypes.cast(tf.val(learningRate), gradient.dataType()),
-        tf.dtypes.cast(tf.val(rho), gradient.dataType()),
-        tf.dtypes.cast(tf.val(epsilon), gradient.dataType()),
+        tf.dtypes.cast(tf.constant(learningRate), gradient.dataType()),
+        tf.dtypes.cast(tf.constant(rho), gradient.dataType()),
+        tf.dtypes.cast(tf.constant(epsilon), gradient.dataType()),
         gradient);
   }
 
diff --git a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaGrad.java b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaGrad.java
index a320153fab5..541b60f4733 100644
--- a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaGrad.java
+++ b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaGrad.java
@@ -65,7 +65,7 @@ protected void createSlots(List<Output<? extends TType>> variables) {
 
   private <T extends TType> void createAdaGradSlot(Output<T> v) {
     Operand<T> initializer = tf.fill(tf.shape(v),
-        tf.dtypes.cast(tf.val(initialAccumulatorValue), v.dataType()));
+        tf.dtypes.cast(tf.constant(initialAccumulatorValue), v.dataType()));
     createSlot(v.asOutput(), ACCUMULATOR, initializer);
   }
 
@@ -73,7 +73,7 @@ private <T extends TType> void createAdaGradSlot(Output<T> v) {
   protected <T extends TType> Operand<T> applyDense(Output<T> gradient, Output<T> variable) {
     Variable<T> slot = getSlot(variable, ACCUMULATOR).get();
     return tf.train
-        .applyAdagrad(variable, slot, tf.dtypes.cast(tf.val(learningRate), gradient.dataType()),
+        .applyAdagrad(variable, slot, tf.dtypes.cast(tf.constant(learningRate), gradient.dataType()),
             gradient);
   }
 
diff --git a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaGradDA.java b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaGradDA.java
index 4c4fc8d24ef..e4f0298537d 100644
--- a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaGradDA.java
+++ b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaGradDA.java
@@ -70,7 +70,7 @@ public AdaGradDA(Graph graph, String name, float learningRate, float initialAccu
 
   @Override
   protected Optional<Operand<?>> prepare(String name) {
-    return Optional.of(tf.assignAdd(globalStep, tf.val(1L)));
+    return Optional.of(tf.assignAdd(globalStep, tf.constant(1L)));
   }
 
   @Override
@@ -79,16 +79,16 @@ protected void createSlots(List<Output<? extends TType>> variables) {
       createAdaGradDASlot(v);
     }
     globalStep = tf.withName("adagrad-da-global-step").variable(Shape.scalar(), TInt64.DTYPE);
-    Assign<TInt64> globalStepInitializer = tf.assign(globalStep, tf.val(0L));
+    Assign<TInt64> globalStepInitializer = tf.assign(globalStep, tf.constant(0L));
     graph.addInitializer(globalStepInitializer);
   }
 
   private <T extends TType> void createAdaGradDASlot(Output<T> v) {
     Operand<T> initializer = tf
-        .fill(tf.shape(v), tf.dtypes.cast(tf.val(0.0f), v.dataType()));
+        .fill(tf.shape(v), tf.dtypes.cast(tf.constant(0.0f), v.dataType()));
     createSlot(v.asOutput(), ACCUMULATOR, initializer);
     Operand<T> sqInitializer = tf.fill(tf.shape(v),
-        tf.dtypes.cast(tf.val(initialAccumulatorValue), v.dataType()));
+        tf.dtypes.cast(tf.constant(initialAccumulatorValue), v.dataType()));
     createSlot(v.asOutput(), SQUARED_ACCUMULATOR, sqInitializer);
   }
 
@@ -97,9 +97,9 @@ protected <T extends TType> Operand<T> applyDense(Output<T> gradient, Output<T>
     Variable<T> gradSlot = getSlot(variable, ACCUMULATOR).get();
     Variable<T> gradSquaredSlot = getSlot(variable, SQUARED_ACCUMULATOR).get();
     return tf.train.applyAdagradDa(variable, gradSlot, gradSquaredSlot, gradient,
-        tf.dtypes.cast(tf.val(learningRate), gradient.dataType()),
-        tf.dtypes.cast(tf.val(l1Strength), gradient.dataType()),
-        tf.dtypes.cast(tf.val(l2Strength), gradient.dataType()),
+        tf.dtypes.cast(tf.constant(learningRate), gradient.dataType()),
+        tf.dtypes.cast(tf.constant(l1Strength), gradient.dataType()),
+        tf.dtypes.cast(tf.constant(l2Strength), gradient.dataType()),
         globalStep);
   }
 
@@ -114,7 +114,7 @@ protected <T extends TType> Operand<T> applyDense(Output<T> gradient, Output<T>
    */
   @Override
   protected Op finish(List<Operand<?>> updateOperations, String name) {
-    updateOperations.add(tf.assignAdd(globalStep, tf.val(1L)));
+    updateOperations.add(tf.assignAdd(globalStep, tf.constant(1L)));
     return super.finish(updateOperations, name);
   }
 
diff --git a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Adam.java b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Adam.java
index 4a0afb6ae2f..9ee87436e28 100644
--- a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Adam.java
+++ b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Adam.java
@@ -109,29 +109,29 @@ protected void createSlots(List<Output<? extends TType>> variables) {
     }
     betaOnePower = tf.withName("beta1_power").variable(Shape.scalar(), TFloat32.DTYPE);
     Assign<TFloat32> betaOnePowerInit = tf
-        .assign(betaOnePower, tf.val(betaOne));
+        .assign(betaOnePower, tf.constant(betaOne));
     graph.addInitializer(betaOnePowerInit);
     betaTwoPower = tf.withName("beta2_power").variable(Shape.scalar(), TFloat32.DTYPE);
     Assign<TFloat32> betaTwoPowerInit = tf
-        .assign(betaTwoPower, tf.val(betaTwo));
+        .assign(betaTwoPower, tf.constant(betaTwo));
     graph.addInitializer(betaTwoPowerInit);
   }
 
   @Override
   protected Optional<Operand<?>> prepare(String scopeName) {
-    betaOneConst = tf.val(betaOne);
-    betaTwoConst = tf.val(betaTwo);
-    learningRateConst = tf.val(learningRate);
-    epsilonConst = tf.val(epsilon);
+    betaOneConst = tf.constant(betaOne);
+    betaTwoConst = tf.constant(betaTwo);
+    learningRateConst = tf.constant(learningRate);
+    epsilonConst = tf.constant(epsilon);
     return Optional.empty();
   }
 
   private <T extends TType> void createAdamSlot(Output<T> v) {
     Operand<T> firstMomentInitializer = tf
-        .fill(tf.shape(v), tf.dtypes.cast(tf.val(0.0f), v.dataType()));
+        .fill(tf.shape(v), tf.dtypes.cast(tf.constant(0.0f), v.dataType()));
     createSlot(v.asOutput(), FIRST_MOMENT, firstMomentInitializer);
     Operand<T> secondMomentInitializer = tf
-        .fill(tf.shape(v), tf.dtypes.cast(tf.val(0.0f), v.dataType()));
+        .fill(tf.shape(v), tf.dtypes.cast(tf.constant(0.0f), v.dataType()));
     createSlot(v.asOutput(), SECOND_MOMENT, secondMomentInitializer);
   }
 
diff --git a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/GradientDescent.java b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/GradientDescent.java
index 58267bc2534..f6890e711f8 100644
--- a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/GradientDescent.java
+++ b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/GradientDescent.java
@@ -40,7 +40,7 @@ public GradientDescent(Graph graph, String name, float learningRate) {
   @Override
   protected <T extends TType> Operand<T> applyDense(Output<T> gradient, Output<T> variable) {
     return tf.train.applyGradientDescent(variable,
-        tf.dtypes.cast(tf.val(learningRate), gradient.dataType()), gradient);
+        tf.dtypes.cast(tf.constant(learningRate), gradient.dataType()), gradient);
   }
 
   @Override
diff --git a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Momentum.java b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Momentum.java
index fcec40bf9d3..98d69451330 100644
--- a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Momentum.java
+++ b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Momentum.java
@@ -62,7 +62,7 @@ protected void createSlots(List<Output<? extends TType>> variables) {
 
   private <T extends TType> void createMomentumSlot(Output<T> v) {
     Operand<T> initializer = tf
-        .fill(tf.shape(v), tf.dtypes.cast(tf.val(0.0f), v.dataType()));
+        .fill(tf.shape(v), tf.dtypes.cast(tf.constant(0.0f), v.dataType()));
     createSlot(v.asOutput(), MOMENTUM, initializer);
   }
 
@@ -70,9 +70,9 @@ private <T extends TType> void createMomentumSlot(Output<T> v) {
   protected <T extends TType> Operand<T> applyDense(Output<T> gradient, Output<T> variable) {
     Variable<T> slot = getSlot(variable, MOMENTUM).get();
     return tf.train
-        .applyMomentum(variable, slot, tf.dtypes.cast(tf.val(learningRate), gradient.dataType()),
+        .applyMomentum(variable, slot, tf.dtypes.cast(tf.constant(learningRate), gradient.dataType()),
             gradient,
-            tf.dtypes.cast(tf.val(momentum), gradient.dataType()),
+            tf.dtypes.cast(tf.constant(momentum), gradient.dataType()),
             ApplyMomentum.useNesterov(useNesterov));
   }
 
diff --git a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/RMSProp.java b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/RMSProp.java
index 5ac18bd7163..4e7bf66f37a 100644
--- a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/RMSProp.java
+++ b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/RMSProp.java
@@ -77,14 +77,14 @@ protected void createSlots(List<Output<? extends TType>> variables) {
 
   private <T extends TType> void createRMSPropSlot(Output<T> v) {
     Operand<T> rmsInitializer = tf
-        .fill(tf.shape(v), tf.dtypes.cast(tf.val(1.0f), v.dataType()));
+        .fill(tf.shape(v), tf.dtypes.cast(tf.constant(1.0f), v.dataType()));
     createSlot(v.asOutput(), RMS, rmsInitializer);
     Operand<T> momentumInitializer = tf
-        .fill(tf.shape(v), tf.dtypes.cast(tf.val(0.0f), v.dataType()));
+        .fill(tf.shape(v), tf.dtypes.cast(tf.constant(0.0f), v.dataType()));
     createSlot(v.asOutput(), MOMENTUM, momentumInitializer);
     if (centered) {
       Operand<T> mgInitializer = tf
-          .fill(tf.shape(v), tf.dtypes.cast(tf.val(0.0f), v.dataType()));
+          .fill(tf.shape(v), tf.dtypes.cast(tf.constant(0.0f), v.dataType()));
       createSlot(v.asOutput(), MG, mgInitializer);
     }
   }
@@ -96,17 +96,17 @@ protected <T extends TType> Operand<T> applyDense(Output<T> gradient, Output<T>
     if (centered) {
       Variable<T> mgSlot = getSlot(variable, MG).get();
       return tf.train.applyCenteredRmsProp(variable, mgSlot, rmsSlot, momentumSlot,
-          tf.dtypes.cast(tf.val(learningRate), gradient.dataType()),
-          tf.dtypes.cast(tf.val(decay), gradient.dataType()),
-          tf.dtypes.cast(tf.val(momentum), gradient.dataType()),
-          tf.dtypes.cast(tf.val(epsilon), gradient.dataType()),
+          tf.dtypes.cast(tf.constant(learningRate), gradient.dataType()),
+          tf.dtypes.cast(tf.constant(decay), gradient.dataType()),
+          tf.dtypes.cast(tf.constant(momentum), gradient.dataType()),
+          tf.dtypes.cast(tf.constant(epsilon), gradient.dataType()),
           gradient);
     }
     return tf.train.applyRmsProp(variable, rmsSlot, momentumSlot,
-        tf.dtypes.cast(tf.val(learningRate), gradient.dataType()),
-        tf.dtypes.cast(tf.val(decay), gradient.dataType()),
-        tf.dtypes.cast(tf.val(momentum), gradient.dataType()),
-        tf.dtypes.cast(tf.val(epsilon), gradient.dataType()),
+        tf.dtypes.cast(tf.constant(learningRate), gradient.dataType()),
+        tf.dtypes.cast(tf.constant(decay), gradient.dataType()),
+        tf.dtypes.cast(tf.constant(momentum), gradient.dataType()),
+        tf.dtypes.cast(tf.constant(epsilon), gradient.dataType()),
         gradient);
   }
 

From 2cdccbca0f81d1384cdf9f08534d83412f4af2d0 Mon Sep 17 00:00:00 2001
From: Karl Lessard <karl.lessard@gmail.com>
Date: Thu, 26 Mar 2020 22:11:56 -0400
Subject: [PATCH 2/7] Rename 'PrimitiveOp' to 'RawOp'

---
 .../src/bazel/op_generator/op_generator.cc    |  2 +-
 .../annotations/org/tensorflow/op/Ops.java    |  4 +-
 .../tensorflow/op/audio/AudioSpectrogram.java |  4 +-
 .../org/tensorflow/op/audio/DecodeWav.java    |  4 +-
 .../org/tensorflow/op/audio/EncodeWav.java    |  4 +-
 .../java/org/tensorflow/op/audio/Mfcc.java    |  4 +-
 .../org/tensorflow/op/bitwise/BitwiseAnd.java |  4 +-
 .../org/tensorflow/op/bitwise/BitwiseOr.java  |  4 +-
 .../org/tensorflow/op/bitwise/BitwiseXor.java |  4 +-
 .../org/tensorflow/op/bitwise/Invert.java     |  4 +-
 .../org/tensorflow/op/bitwise/LeftShift.java  |  4 +-
 .../org/tensorflow/op/bitwise/RightShift.java |  4 +-
 .../op/cluster/KMC2ChainInitialization.java   |  4 +-
 .../cluster/KmeansPlusPlusInitialization.java |  4 +-
 .../tensorflow/op/collective/AllReduce.java   |  4 +-
 .../op/collective/BroadcastRecv.java          |  4 +-
 .../op/collective/BroadcastSend.java          |  4 +-
 .../java/org/tensorflow/op/core/Abort.java    |  4 +-
 .../gen/java/org/tensorflow/op/core/All.java  |  4 +-
 .../gen/java/org/tensorflow/op/core/Any.java  |  4 +-
 .../org/tensorflow/op/core/AssertThat.java    |  4 +-
 .../java/org/tensorflow/op/core/Assign.java   |  4 +-
 .../org/tensorflow/op/core/AssignAdd.java     |  4 +-
 .../op/core/AssignAddVariableOp.java          |  4 +-
 .../org/tensorflow/op/core/AssignSub.java     |  4 +-
 .../op/core/AssignSubVariableOp.java          |  4 +-
 .../tensorflow/op/core/AssignVariableOp.java  |  4 +-
 .../java/org/tensorflow/op/core/Barrier.java  |  4 +-
 .../org/tensorflow/op/core/BarrierClose.java  |  4 +-
 .../op/core/BarrierIncompleteSize.java        |  4 +-
 .../tensorflow/op/core/BarrierInsertMany.java |  4 +-
 .../tensorflow/op/core/BarrierReadySize.java  |  4 +-
 .../tensorflow/op/core/BarrierTakeMany.java   |  4 +-
 .../java/org/tensorflow/op/core/Batch.java    |  4 +-
 .../org/tensorflow/op/core/BatchToSpace.java  |  4 +-
 .../tensorflow/op/core/BatchToSpaceNd.java    |  4 +-
 .../java/org/tensorflow/op/core/Bitcast.java  |  4 +-
 .../op/core/BroadcastDynamicShape.java        |  4 +-
 .../op/core/BroadcastGradientArgs.java        |  4 +-
 .../org/tensorflow/op/core/BroadcastTo.java   |  4 +-
 .../org/tensorflow/op/core/Bucketize.java     |  4 +-
 .../org/tensorflow/op/core/ClipByValue.java   |  4 +-
 .../tensorflow/op/core/CollectiveGather.java  |  4 +-
 .../java/org/tensorflow/op/core/Concat.java   |  4 +-
 .../tensorflow/op/core/ConsumeMutexLock.java  |  4 +-
 .../tensorflow/op/core/ControlTrigger.java    |  4 +-
 .../gen/java/org/tensorflow/op/core/Copy.java |  4 +-
 .../java/org/tensorflow/op/core/CopyHost.java |  4 +-
 .../org/tensorflow/op/core/CountUpTo.java     |  4 +-
 .../op/core/DebugGradientIdentity.java        |  4 +-
 .../op/core/DebugGradientRefIdentity.java     |  4 +-
 .../org/tensorflow/op/core/DebugIdentity.java |  4 +-
 .../tensorflow/op/core/DebugIdentityV2.java   |  4 +-
 .../org/tensorflow/op/core/DebugNanCount.java |  4 +-
 .../op/core/DebugNumericSummary.java          |  4 +-
 .../op/core/DebugNumericSummaryV2.java        |  4 +-
 .../org/tensorflow/op/core/DecodeProto.java   |  4 +-
 .../java/org/tensorflow/op/core/DeepCopy.java |  4 +-
 .../op/core/DeleteSessionTensor.java          |  4 +-
 .../tensorflow/op/core/DestroyResourceOp.java |  4 +-
 .../op/core/DestroyTemporaryVariable.java     |  4 +-
 .../tensorflow/op/core/DynamicPartition.java  |  4 +-
 .../org/tensorflow/op/core/DynamicStitch.java |  4 +-
 .../org/tensorflow/op/core/EditDistance.java  |  4 +-
 .../java/org/tensorflow/op/core/Empty.java    |  4 +-
 .../tensorflow/op/core/EmptyTensorList.java   |  4 +-
 .../org/tensorflow/op/core/EncodeProto.java   |  4 +-
 .../org/tensorflow/op/core/EnsureShape.java   |  4 +-
 .../java/org/tensorflow/op/core/Enter.java    |  4 +-
 .../gen/java/org/tensorflow/op/core/Exit.java |  4 +-
 .../org/tensorflow/op/core/ExpandDims.java    |  4 +-
 .../op/core/ExtractVolumePatches.java         |  4 +-
 .../gen/java/org/tensorflow/op/core/Fill.java |  4 +-
 .../org/tensorflow/op/core/Fingerprint.java   |  4 +-
 .../java/org/tensorflow/op/core/Gather.java   |  4 +-
 .../java/org/tensorflow/op/core/GatherNd.java |  4 +-
 .../tensorflow/op/core/GetSessionHandle.java  |  4 +-
 .../tensorflow/op/core/GetSessionTensor.java  |  4 +-
 .../tensorflow/op/core/GuaranteeConst.java    |  4 +-
 .../org/tensorflow/op/core/HashTable.java     |  4 +-
 .../op/core/HistogramFixedWidth.java          |  4 +-
 .../java/org/tensorflow/op/core/Identity.java |  4 +-
 .../org/tensorflow/op/core/IdentityN.java     |  4 +-
 .../tensorflow/op/core/ImmutableConst.java    |  4 +-
 .../tensorflow/op/core/InitializeTable.java   |  4 +-
 .../op/core/InitializeTableFromTextFile.java  |  4 +-
 .../org/tensorflow/op/core/InplaceAdd.java    |  4 +-
 .../org/tensorflow/op/core/InplaceSub.java    |  4 +-
 .../org/tensorflow/op/core/InplaceUpdate.java |  4 +-
 .../op/core/IsVariableInitialized.java        |  4 +-
 .../java/org/tensorflow/op/core/LinSpace.java |  4 +-
 .../tensorflow/op/core/LookupTableExport.java |  4 +-
 .../tensorflow/op/core/LookupTableFind.java   |  4 +-
 .../tensorflow/op/core/LookupTableImport.java |  4 +-
 .../tensorflow/op/core/LookupTableInsert.java |  4 +-
 .../tensorflow/op/core/LookupTableRemove.java |  4 +-
 .../tensorflow/op/core/LookupTableSize.java   |  4 +-
 .../java/org/tensorflow/op/core/LoopCond.java |  4 +-
 .../org/tensorflow/op/core/LowerBound.java    |  4 +-
 .../java/org/tensorflow/op/core/MapClear.java |  4 +-
 .../tensorflow/op/core/MapIncompleteSize.java |  4 +-
 .../java/org/tensorflow/op/core/MapPeek.java  |  4 +-
 .../java/org/tensorflow/op/core/MapSize.java  |  4 +-
 .../java/org/tensorflow/op/core/MapStage.java |  4 +-
 .../org/tensorflow/op/core/MapUnstage.java    |  4 +-
 .../tensorflow/op/core/MapUnstageNoKey.java   |  4 +-
 .../gen/java/org/tensorflow/op/core/Max.java  |  4 +-
 .../java/org/tensorflow/op/core/Merge.java    |  4 +-
 .../gen/java/org/tensorflow/op/core/Min.java  |  4 +-
 .../org/tensorflow/op/core/MirrorPad.java     |  4 +-
 .../org/tensorflow/op/core/MirrorPadGrad.java |  4 +-
 .../tensorflow/op/core/MlirPassthroughOp.java |  4 +-
 .../op/core/MutableDenseHashTable.java        |  4 +-
 .../tensorflow/op/core/MutableHashTable.java  |  4 +-
 .../op/core/MutableHashTableOfTensors.java    |  4 +-
 .../java/org/tensorflow/op/core/Mutex.java    |  4 +-
 .../org/tensorflow/op/core/MutexLock.java     |  4 +-
 .../org/tensorflow/op/core/NcclAllReduce.java |  4 +-
 .../org/tensorflow/op/core/NcclBroadcast.java |  4 +-
 .../org/tensorflow/op/core/NcclReduce.java    |  4 +-
 .../org/tensorflow/op/core/NextIteration.java |  4 +-
 .../gen/java/org/tensorflow/op/core/NoOp.java |  4 +-
 .../java/org/tensorflow/op/core/OneHot.java   |  4 +-
 .../java/org/tensorflow/op/core/OnesLike.java |  4 +-
 .../tensorflow/op/core/OrderedMapClear.java   |  4 +-
 .../op/core/OrderedMapIncompleteSize.java     |  4 +-
 .../tensorflow/op/core/OrderedMapPeek.java    |  4 +-
 .../tensorflow/op/core/OrderedMapSize.java    |  4 +-
 .../tensorflow/op/core/OrderedMapStage.java   |  4 +-
 .../tensorflow/op/core/OrderedMapUnstage.java |  4 +-
 .../op/core/OrderedMapUnstageNoKey.java       |  4 +-
 .../gen/java/org/tensorflow/op/core/Pad.java  |  4 +-
 .../tensorflow/op/core/ParallelConcat.java    |  4 +-
 .../op/core/ParallelDynamicStitch.java        |  4 +-
 .../org/tensorflow/op/core/Placeholder.java   |  4 +-
 .../op/core/PlaceholderWithDefault.java       |  4 +-
 .../java/org/tensorflow/op/core/Print.java    |  4 +-
 .../gen/java/org/tensorflow/op/core/Prod.java |  4 +-
 .../tensorflow/op/core/QuantizedReshape.java  |  4 +-
 .../java/org/tensorflow/op/core/Range.java    |  4 +-
 .../gen/java/org/tensorflow/op/core/Rank.java |  4 +-
 .../tensorflow/op/core/ReadVariableOp.java    |  4 +-
 .../gen/java/org/tensorflow/op/core/Recv.java |  4 +-
 .../org/tensorflow/op/core/ReduceAll.java     |  4 +-
 .../org/tensorflow/op/core/ReduceAny.java     |  4 +-
 .../org/tensorflow/op/core/ReduceMax.java     |  4 +-
 .../org/tensorflow/op/core/ReduceMin.java     |  4 +-
 .../org/tensorflow/op/core/ReduceProd.java    |  4 +-
 .../org/tensorflow/op/core/ReduceSum.java     |  4 +-
 .../java/org/tensorflow/op/core/RefEnter.java |  4 +-
 .../java/org/tensorflow/op/core/RefExit.java  |  4 +-
 .../org/tensorflow/op/core/RefIdentity.java   |  4 +-
 .../java/org/tensorflow/op/core/RefMerge.java |  4 +-
 .../tensorflow/op/core/RefNextIteration.java  |  4 +-
 .../org/tensorflow/op/core/RefSelect.java     |  4 +-
 .../org/tensorflow/op/core/RefSwitch.java     |  4 +-
 .../op/core/RemoteFusedGraphExecute.java      |  4 +-
 .../java/org/tensorflow/op/core/Reshape.java  |  4 +-
 .../tensorflow/op/core/ResourceCountUpTo.java |  4 +-
 .../tensorflow/op/core/ResourceGather.java    |  4 +-
 .../tensorflow/op/core/ResourceGatherNd.java  |  4 +-
 .../op/core/ResourceScatterAdd.java           |  4 +-
 .../op/core/ResourceScatterDiv.java           |  4 +-
 .../op/core/ResourceScatterMax.java           |  4 +-
 .../op/core/ResourceScatterMin.java           |  4 +-
 .../op/core/ResourceScatterMul.java           |  4 +-
 .../op/core/ResourceScatterNdAdd.java         |  4 +-
 .../op/core/ResourceScatterNdSub.java         |  4 +-
 .../op/core/ResourceScatterNdUpdate.java      |  4 +-
 .../op/core/ResourceScatterSub.java           |  4 +-
 .../op/core/ResourceScatterUpdate.java        |  4 +-
 .../op/core/ResourceStridedSliceAssign.java   |  4 +-
 .../java/org/tensorflow/op/core/Reverse.java  |  4 +-
 .../tensorflow/op/core/ReverseSequence.java   |  4 +-
 .../gen/java/org/tensorflow/op/core/Roll.java |  4 +-
 .../gen/java/org/tensorflow/op/core/Rpc.java  |  4 +-
 .../org/tensorflow/op/core/ScatterAdd.java    |  4 +-
 .../org/tensorflow/op/core/ScatterDiv.java    |  4 +-
 .../org/tensorflow/op/core/ScatterMax.java    |  4 +-
 .../org/tensorflow/op/core/ScatterMin.java    |  4 +-
 .../org/tensorflow/op/core/ScatterMul.java    |  4 +-
 .../org/tensorflow/op/core/ScatterNd.java     |  4 +-
 .../org/tensorflow/op/core/ScatterNdAdd.java  |  4 +-
 .../op/core/ScatterNdNonAliasingAdd.java      |  4 +-
 .../org/tensorflow/op/core/ScatterNdSub.java  |  4 +-
 .../tensorflow/op/core/ScatterNdUpdate.java   |  4 +-
 .../org/tensorflow/op/core/ScatterSub.java    |  4 +-
 .../org/tensorflow/op/core/ScatterUpdate.java |  4 +-
 .../java/org/tensorflow/op/core/Select.java   |  4 +-
 .../gen/java/org/tensorflow/op/core/Send.java |  4 +-
 .../org/tensorflow/op/core/SetDiff1d.java     |  4 +-
 .../java/org/tensorflow/op/core/SetSize.java  |  4 +-
 .../java/org/tensorflow/op/core/Shape.java    |  4 +-
 .../java/org/tensorflow/op/core/ShapeN.java   |  4 +-
 .../gen/java/org/tensorflow/op/core/Size.java |  4 +-
 .../java/org/tensorflow/op/core/Skipgram.java |  4 +-
 .../java/org/tensorflow/op/core/Slice.java    |  4 +-
 .../java/org/tensorflow/op/core/Snapshot.java |  4 +-
 .../tensorflow/op/core/SpaceToBatchNd.java    |  4 +-
 .../java/org/tensorflow/op/core/Split.java    |  4 +-
 .../java/org/tensorflow/op/core/SplitV.java   |  4 +-
 .../java/org/tensorflow/op/core/Squeeze.java  |  4 +-
 .../java/org/tensorflow/op/core/Stack.java    |  4 +-
 .../java/org/tensorflow/op/core/Stage.java    |  4 +-
 .../org/tensorflow/op/core/StageClear.java    |  4 +-
 .../org/tensorflow/op/core/StagePeek.java     |  4 +-
 .../org/tensorflow/op/core/StageSize.java     |  4 +-
 .../org/tensorflow/op/core/StopGradient.java  |  4 +-
 .../org/tensorflow/op/core/StridedSlice.java  |  4 +-
 .../op/core/StridedSliceAssign.java           |  4 +-
 .../tensorflow/op/core/StridedSliceGrad.java  |  4 +-
 .../gen/java/org/tensorflow/op/core/Sum.java  |  4 +-
 .../org/tensorflow/op/core/SwitchCond.java    |  4 +-
 .../tensorflow/op/core/TemporaryVariable.java |  4 +-
 .../org/tensorflow/op/core/TensorArray.java   |  4 +-
 .../tensorflow/op/core/TensorArrayClose.java  |  4 +-
 .../tensorflow/op/core/TensorArrayConcat.java |  4 +-
 .../tensorflow/op/core/TensorArrayGather.java |  4 +-
 .../tensorflow/op/core/TensorArrayGrad.java   |  4 +-
 .../op/core/TensorArrayGradWithShape.java     |  4 +-
 .../tensorflow/op/core/TensorArrayPack.java   |  4 +-
 .../tensorflow/op/core/TensorArrayRead.java   |  4 +-
 .../op/core/TensorArrayScatter.java           |  4 +-
 .../tensorflow/op/core/TensorArraySize.java   |  4 +-
 .../tensorflow/op/core/TensorArraySplit.java  |  4 +-
 .../tensorflow/op/core/TensorArrayUnpack.java |  4 +-
 .../tensorflow/op/core/TensorArrayWrite.java  |  4 +-
 .../core/TensorForestCreateTreeVariable.java  |  4 +-
 .../op/core/TensorForestTreeDeserialize.java  |  4 +-
 .../core/TensorForestTreeIsInitializedOp.java |  4 +-
 .../op/core/TensorForestTreePredict.java      |  4 +-
 .../TensorForestTreeResourceHandleOp.java     |  4 +-
 .../op/core/TensorForestTreeSerialize.java    |  4 +-
 .../op/core/TensorForestTreeSize.java         |  4 +-
 .../tensorflow/op/core/TensorListConcat.java  |  4 +-
 .../op/core/TensorListConcatLists.java        |  4 +-
 .../op/core/TensorListElementShape.java       |  4 +-
 .../op/core/TensorListFromTensor.java         |  4 +-
 .../tensorflow/op/core/TensorListGather.java  |  4 +-
 .../tensorflow/op/core/TensorListGetItem.java |  4 +-
 .../tensorflow/op/core/TensorListLength.java  |  4 +-
 .../tensorflow/op/core/TensorListPopBack.java |  4 +-
 .../op/core/TensorListPushBack.java           |  4 +-
 .../op/core/TensorListPushBackBatch.java      |  4 +-
 .../tensorflow/op/core/TensorListReserve.java |  4 +-
 .../tensorflow/op/core/TensorListResize.java  |  4 +-
 .../tensorflow/op/core/TensorListScatter.java |  4 +-
 .../TensorListScatterIntoExistingList.java    |  4 +-
 .../tensorflow/op/core/TensorListSetItem.java |  4 +-
 .../tensorflow/op/core/TensorListSplit.java   |  4 +-
 .../tensorflow/op/core/TensorListStack.java   |  4 +-
 .../op/core/TensorScatterNdAdd.java           |  4 +-
 .../op/core/TensorScatterNdSub.java           |  4 +-
 .../op/core/TensorScatterNdUpdate.java        |  4 +-
 .../op/core/TensorStridedSliceUpdate.java     |  4 +-
 .../gen/java/org/tensorflow/op/core/Tile.java |  4 +-
 .../org/tensorflow/op/core/Timestamp.java     |  4 +-
 .../java/org/tensorflow/op/core/TryRpc.java   |  4 +-
 .../java/org/tensorflow/op/core/Unbatch.java  |  4 +-
 .../org/tensorflow/op/core/UnbatchGrad.java   |  4 +-
 .../java/org/tensorflow/op/core/Unique.java   |  4 +-
 .../tensorflow/op/core/UniqueWithCounts.java  |  4 +-
 .../org/tensorflow/op/core/UnravelIndex.java  |  4 +-
 .../java/org/tensorflow/op/core/Unstack.java  |  4 +-
 .../java/org/tensorflow/op/core/Unstage.java  |  4 +-
 .../org/tensorflow/op/core/UpperBound.java    |  4 +-
 .../org/tensorflow/op/core/VarHandleOp.java   |  4 +-
 .../op/core/VarIsInitializedOp.java           |  4 +-
 .../java/org/tensorflow/op/core/Variable.java |  4 +-
 .../org/tensorflow/op/core/VariableShape.java |  4 +-
 .../java/org/tensorflow/op/core/Where.java    |  4 +-
 .../org/tensorflow/op/core/ZerosLike.java     |  4 +-
 .../tensorflow/op/data/AnonymousIterator.java |  4 +-
 .../op/data/AnonymousMemoryCache.java         |  4 +-
 .../op/data/AnonymousMultiDeviceIterator.java |  4 +-
 .../tensorflow/op/data/AssertNextDataset.java |  4 +-
 .../tensorflow/op/data/AutoShardDataset.java  |  4 +-
 .../org/tensorflow/op/data/BatchDataset.java  |  4 +-
 .../op/data/BytesProducedStatsDataset.java    |  4 +-
 .../org/tensorflow/op/data/CSVDataset.java    |  4 +-
 .../org/tensorflow/op/data/CacheDataset.java  |  4 +-
 .../tensorflow/op/data/CacheDatasetV2.java    |  4 +-
 .../op/data/ChooseFastestDataset.java         |  4 +-
 .../op/data/ConcatenateDataset.java           |  4 +-
 .../op/data/DatasetCardinality.java           |  4 +-
 .../tensorflow/op/data/DatasetFromGraph.java  |  4 +-
 .../tensorflow/op/data/DatasetToGraph.java    |  4 +-
 .../op/data/DatasetToSingleElement.java       |  4 +-
 .../tensorflow/op/data/DatasetToTfRecord.java |  4 +-
 .../tensorflow/op/data/DeleteIterator.java    |  4 +-
 .../tensorflow/op/data/DeleteMemoryCache.java |  4 +-
 .../op/data/DeleteMultiDeviceIterator.java    |  4 +-
 .../op/data/DenseToSparseBatchDataset.java    |  4 +-
 .../op/data/DeserializeIterator.java          |  4 +-
 .../op/data/DirectedInterleaveDataset.java    |  4 +-
 .../op/data/FilterByLastComponentDataset.java |  4 +-
 .../op/data/FixedLengthRecordDataset.java     |  4 +-
 .../op/data/IgnoreErrorsDataset.java          |  4 +-
 .../java/org/tensorflow/op/data/Iterator.java |  4 +-
 .../op/data/IteratorFromStringHandle.java     |  4 +-
 .../tensorflow/op/data/IteratorGetDevice.java |  4 +-
 .../tensorflow/op/data/IteratorGetNext.java   |  4 +-
 .../op/data/IteratorGetNextAsOptional.java    |  4 +-
 .../op/data/IteratorGetNextSync.java          |  4 +-
 .../op/data/IteratorToStringHandle.java       |  4 +-
 .../org/tensorflow/op/data/LMDBDataset.java   |  4 +-
 .../op/data/LatencyStatsDataset.java          |  4 +-
 .../org/tensorflow/op/data/LeakyReluGrad.java |  4 +-
 .../org/tensorflow/op/data/MakeIterator.java  |  4 +-
 .../op/data/MatchingFilesDataset.java         |  4 +-
 .../op/data/MaxIntraOpParallelismDataset.java |  4 +-
 .../org/tensorflow/op/data/ModelDataset.java  |  4 +-
 .../op/data/MultiDeviceIterator.java          |  4 +-
 .../MultiDeviceIteratorFromStringHandle.java  |  4 +-
 .../MultiDeviceIteratorGetNextFromShard.java  |  4 +-
 .../op/data/MultiDeviceIteratorInit.java      |  4 +-
 .../MultiDeviceIteratorToStringHandle.java    |  4 +-
 .../op/data/NonSerializableDataset.java       |  4 +-
 .../tensorflow/op/data/OptimizeDataset.java   |  4 +-
 .../tensorflow/op/data/OptionalFromValue.java |  4 +-
 .../tensorflow/op/data/OptionalGetValue.java  |  4 +-
 .../tensorflow/op/data/OptionalHasValue.java  |  4 +-
 .../org/tensorflow/op/data/OptionalNone.java  |  4 +-
 .../op/data/PaddedBatchDataset.java           |  4 +-
 .../tensorflow/op/data/PrefetchDataset.java   |  4 +-
 .../op/data/PrivateThreadPoolDataset.java     |  4 +-
 .../org/tensorflow/op/data/RandomDataset.java |  4 +-
 .../org/tensorflow/op/data/RangeDataset.java  |  4 +-
 .../tensorflow/op/data/RebatchDataset.java    |  4 +-
 .../org/tensorflow/op/data/RepeatDataset.java |  4 +-
 .../tensorflow/op/data/SamplingDataset.java   |  4 +-
 .../tensorflow/op/data/SerializeIterator.java |  4 +-
 .../op/data/SetStatsAggregatorDataset.java    |  4 +-
 .../org/tensorflow/op/data/ShardDataset.java  |  4 +-
 .../op/data/ShuffleAndRepeatDataset.java      |  4 +-
 .../tensorflow/op/data/ShuffleDataset.java    |  4 +-
 .../org/tensorflow/op/data/SkipDataset.java   |  4 +-
 .../org/tensorflow/op/data/SleepDataset.java  |  4 +-
 .../op/data/SlidingWindowDataset.java         |  4 +-
 .../tensorflow/op/data/SnapshotDataset.java   |  4 +-
 .../op/data/SparseTensorSliceDataset.java     |  4 +-
 .../org/tensorflow/op/data/SqlDataset.java    |  4 +-
 .../op/data/StatsAggregatorHandle.java        |  4 +-
 .../org/tensorflow/op/data/TakeDataset.java   |  4 +-
 .../org/tensorflow/op/data/TensorDataset.java |  4 +-
 .../op/data/TensorSliceDataset.java           |  4 +-
 .../tensorflow/op/data/TextLineDataset.java   |  4 +-
 .../tensorflow/op/data/TfRecordDataset.java   |  4 +-
 .../tensorflow/op/data/ThreadPoolDataset.java |  4 +-
 .../tensorflow/op/data/ThreadPoolHandle.java  |  4 +-
 .../tensorflow/op/data/UnbatchDataset.java    |  4 +-
 .../org/tensorflow/op/data/UniqueDataset.java |  4 +-
 .../op/data/UnwrapDatasetVariant.java         |  4 +-
 .../org/tensorflow/op/data/WindowDataset.java |  4 +-
 .../op/data/WrapDatasetVariant.java           |  4 +-
 .../org/tensorflow/op/data/ZipDataset.java    |  4 +-
 .../data/experimental/AssertNextDataset.java  |  4 +-
 .../data/experimental/AutoShardDataset.java   |  4 +-
 .../BytesProducedStatsDataset.java            |  4 +-
 .../op/data/experimental/CSVDataset.java      |  4 +-
 .../experimental/ChooseFastestDataset.java    |  4 +-
 .../data/experimental/DatasetCardinality.java |  4 +-
 .../data/experimental/DatasetToTFRecord.java  |  4 +-
 .../DenseToSparseBatchDataset.java            |  4 +-
 .../DirectedInterleaveDataset.java            |  4 +-
 .../experimental/IgnoreErrorsDataset.java     |  4 +-
 .../data/experimental/IteratorGetDevice.java  |  4 +-
 .../experimental/LatencyStatsDataset.java     |  4 +-
 .../op/data/experimental/LmdbDataset.java     |  4 +-
 .../experimental/MatchingFilesDataset.java    |  4 +-
 .../MaxIntraOpParallelismDataset.java         |  4 +-
 .../experimental/NonSerializableDataset.java  |  4 +-
 .../experimental/ParseExampleDataset.java     |  4 +-
 .../PrivateThreadPoolDataset.java             |  4 +-
 .../op/data/experimental/RandomDataset.java   |  4 +-
 .../op/data/experimental/RebatchDataset.java  |  4 +-
 .../SetStatsAggregatorDataset.java            |  4 +-
 .../op/data/experimental/SleepDataset.java    |  4 +-
 .../experimental/SlidingWindowDataset.java    |  4 +-
 .../op/data/experimental/SqlDataset.java      |  4 +-
 .../experimental/StatsAggregatorHandle.java   |  4 +-
 .../StatsAggregatorSetSummaryWriter.java      |  4 +-
 .../experimental/StatsAggregatorSummary.java  |  4 +-
 .../data/experimental/ThreadPoolDataset.java  |  4 +-
 .../data/experimental/ThreadPoolHandle.java   |  4 +-
 .../op/data/experimental/UnbatchDataset.java  |  4 +-
 .../op/data/experimental/UniqueDataset.java   |  4 +-
 .../org/tensorflow/op/dtypes/AsString.java    |  4 +-
 .../java/org/tensorflow/op/dtypes/Cast.java   |  4 +-
 .../org/tensorflow/op/dtypes/Complex.java     |  4 +-
 .../estimator/BoostedTreesAggregateStats.java |  4 +-
 .../op/estimator/BoostedTreesBucketize.java   |  4 +-
 ...BoostedTreesCalculateBestFeatureSplit.java |  4 +-
 ...stedTreesCalculateBestGainsPerFeature.java |  4 +-
 .../op/estimator/BoostedTreesCenterBias.java  |  4 +-
 .../estimator/BoostedTreesCreateEnsemble.java |  4 +-
 ...stedTreesCreateQuantileStreamResource.java |  4 +-
 .../BoostedTreesDeserializeEnsemble.java      |  4 +-
 .../BoostedTreesEnsembleResourceHandleOp.java |  4 +-
 .../BoostedTreesExampleDebugOutputs.java      |  4 +-
 .../BoostedTreesFlushQuantileSummaries.java   |  4 +-
 .../BoostedTreesGetEnsembleStates.java        |  4 +-
 .../BoostedTreesMakeQuantileSummaries.java    |  4 +-
 .../BoostedTreesMakeStatsSummary.java         |  4 +-
 .../op/estimator/BoostedTreesPredict.java     |  4 +-
 ...eesQuantileStreamResourceAddSummaries.java |  4 +-
 ...reesQuantileStreamResourceDeserialize.java |  4 +-
 ...ostedTreesQuantileStreamResourceFlush.java |  4 +-
 ...tileStreamResourceGetBucketBoundaries.java |  4 +-
 ...edTreesQuantileStreamResourceHandleOp.java |  4 +-
 .../BoostedTreesSerializeEnsemble.java        |  4 +-
 .../BoostedTreesSparseAggregateStats.java     |  4 +-
 ...dTreesSparseCalculateBestFeatureSplit.java |  4 +-
 .../BoostedTreesTrainingPredict.java          |  4 +-
 .../estimator/BoostedTreesUpdateEnsemble.java |  4 +-
 .../BoostedTreesUpdateEnsembleV2.java         |  4 +-
 .../IsBoostedTreesEnsembleInitialized.java    |  4 +-
 ...reesQuantileStreamResourceInitialized.java |  4 +-
 .../tensorflow/op/image/AdjustContrast.java   |  4 +-
 .../org/tensorflow/op/image/AdjustHue.java    |  4 +-
 .../tensorflow/op/image/AdjustSaturation.java |  4 +-
 .../op/image/CombinedNonMaxSuppression.java   |  4 +-
 .../tensorflow/op/image/CropAndResize.java    |  4 +-
 .../op/image/CropAndResizeGradBoxes.java      |  4 +-
 .../op/image/CropAndResizeGradImage.java      |  4 +-
 .../op/image/DecodeAndCropJpeg.java           |  4 +-
 .../org/tensorflow/op/image/DecodeBmp.java    |  4 +-
 .../org/tensorflow/op/image/DecodeGif.java    |  4 +-
 .../org/tensorflow/op/image/DecodeJpeg.java   |  4 +-
 .../org/tensorflow/op/image/DecodePng.java    |  4 +-
 .../op/image/DrawBoundingBoxes.java           |  4 +-
 .../org/tensorflow/op/image/EncodeJpeg.java   |  4 +-
 .../op/image/EncodeJpegVariableQuality.java   |  4 +-
 .../org/tensorflow/op/image/EncodePng.java    |  4 +-
 .../tensorflow/op/image/ExtractGlimpse.java   |  4 +-
 .../op/image/ExtractImagePatches.java         |  4 +-
 .../tensorflow/op/image/ExtractJpegShape.java |  4 +-
 .../image/GenerateBoundingBoxProposals.java   |  4 +-
 .../org/tensorflow/op/image/HsvToRgb.java     |  4 +-
 .../tensorflow/op/image/NearestNeighbors.java |  4 +-
 .../op/image/NonMaxSuppression.java           |  4 +-
 .../image/NonMaxSuppressionWithOverlaps.java  |  4 +-
 .../op/image/QuantizedResizeBilinear.java     |  4 +-
 .../org/tensorflow/op/image/RandomCrop.java   |  4 +-
 .../org/tensorflow/op/image/ResizeArea.java   |  4 +-
 .../tensorflow/op/image/ResizeBicubic.java    |  4 +-
 .../op/image/ResizeBicubicGrad.java           |  4 +-
 .../tensorflow/op/image/ResizeBilinear.java   |  4 +-
 .../op/image/ResizeBilinearGrad.java          |  4 +-
 .../op/image/ResizeNearestNeighbor.java       |  4 +-
 .../op/image/ResizeNearestNeighborGrad.java   |  4 +-
 .../org/tensorflow/op/image/RgbToHsv.java     |  4 +-
 .../op/image/SampleDistortedBoundingBox.java  |  4 +-
 .../op/image/ScaleAndTranslate.java           |  4 +-
 .../op/image/ScaleAndTranslateGrad.java       |  4 +-
 .../org/tensorflow/op/io/DecodeBase64.java    |  4 +-
 .../tensorflow/op/io/DecodeCompressed.java    |  4 +-
 .../java/org/tensorflow/op/io/DecodeCsv.java  |  4 +-
 .../tensorflow/op/io/DecodeJsonExample.java   |  4 +-
 .../org/tensorflow/op/io/DecodePaddedRaw.java |  4 +-
 .../java/org/tensorflow/op/io/DecodeRaw.java  |  4 +-
 .../op/io/DeserializeManySparse.java          |  4 +-
 .../org/tensorflow/op/io/EncodeBase64.java    |  4 +-
 .../java/org/tensorflow/op/io/FifoQueue.java  |  4 +-
 .../op/io/FixedLengthRecordReader.java        |  4 +-
 .../org/tensorflow/op/io/IdentityReader.java  |  4 +-
 .../java/org/tensorflow/op/io/LmdbReader.java |  4 +-
 .../org/tensorflow/op/io/MatchingFiles.java   |  4 +-
 .../tensorflow/op/io/PaddingFifoQueue.java    |  4 +-
 .../org/tensorflow/op/io/ParseExample.java    |  4 +-
 .../op/io/ParseSequenceExample.java           |  4 +-
 .../tensorflow/op/io/ParseSingleExample.java  |  4 +-
 .../op/io/ParseSingleSequenceExample.java     |  4 +-
 .../org/tensorflow/op/io/ParseTensor.java     |  4 +-
 .../org/tensorflow/op/io/PriorityQueue.java   |  4 +-
 .../java/org/tensorflow/op/io/QueueClose.java |  4 +-
 .../org/tensorflow/op/io/QueueDequeue.java    |  4 +-
 .../tensorflow/op/io/QueueDequeueMany.java    |  4 +-
 .../tensorflow/op/io/QueueDequeueUpTo.java    |  4 +-
 .../org/tensorflow/op/io/QueueEnqueue.java    |  4 +-
 .../tensorflow/op/io/QueueEnqueueMany.java    |  4 +-
 .../org/tensorflow/op/io/QueueIsClosed.java   |  4 +-
 .../java/org/tensorflow/op/io/QueueSize.java  |  4 +-
 .../tensorflow/op/io/RandomShuffleQueue.java  |  4 +-
 .../java/org/tensorflow/op/io/ReadFile.java   |  4 +-
 .../op/io/ReaderNumRecordsProduced.java       |  4 +-
 .../op/io/ReaderNumWorkUnitsCompleted.java    |  4 +-
 .../java/org/tensorflow/op/io/ReaderRead.java |  4 +-
 .../org/tensorflow/op/io/ReaderReadUpTo.java  |  4 +-
 .../org/tensorflow/op/io/ReaderReset.java     |  4 +-
 .../tensorflow/op/io/ReaderRestoreState.java  |  4 +-
 .../op/io/ReaderSerializeState.java           |  4 +-
 .../tensorflow/op/io/SerializeManySparse.java |  4 +-
 .../org/tensorflow/op/io/SerializeSparse.java |  4 +-
 .../org/tensorflow/op/io/SerializeTensor.java |  4 +-
 .../org/tensorflow/op/io/ShardedFilename.java |  4 +-
 .../org/tensorflow/op/io/ShardedFilespec.java |  4 +-
 .../org/tensorflow/op/io/TextLineReader.java  |  4 +-
 .../org/tensorflow/op/io/TfRecordReader.java  |  4 +-
 .../org/tensorflow/op/io/WholeFileReader.java |  4 +-
 .../java/org/tensorflow/op/io/WriteFile.java  |  4 +-
 .../org/tensorflow/op/linalg/BandPart.java    |  4 +-
 .../tensorflow/op/linalg/BatchCholesky.java   |  4 +-
 .../op/linalg/BatchCholeskyGrad.java          |  4 +-
 .../op/linalg/BatchMatrixBandPart.java        |  4 +-
 .../op/linalg/BatchMatrixDeterminant.java     |  4 +-
 .../tensorflow/op/linalg/BatchMatrixDiag.java |  4 +-
 .../op/linalg/BatchMatrixDiagPart.java        |  4 +-
 .../op/linalg/BatchMatrixInverse.java         |  4 +-
 .../op/linalg/BatchMatrixSetDiag.java         |  4 +-
 .../op/linalg/BatchMatrixSolve.java           |  4 +-
 .../op/linalg/BatchMatrixSolveLs.java         |  4 +-
 .../op/linalg/BatchMatrixTriangularSolve.java |  4 +-
 .../op/linalg/BatchSelfAdjointEig.java        |  4 +-
 .../org/tensorflow/op/linalg/BatchSvd.java    |  4 +-
 .../org/tensorflow/op/linalg/Cholesky.java    |  4 +-
 .../tensorflow/op/linalg/CholeskyGrad.java    |  4 +-
 .../op/linalg/ConjugateTranspose.java         |  4 +-
 .../java/org/tensorflow/op/linalg/Cross.java  |  4 +-
 .../java/org/tensorflow/op/linalg/Det.java    |  4 +-
 .../java/org/tensorflow/op/linalg/Eig.java    |  4 +-
 .../java/org/tensorflow/op/linalg/Einsum.java |  4 +-
 .../tensorflow/op/linalg/EuclideanNorm.java   |  4 +-
 .../java/org/tensorflow/op/linalg/Inv.java    |  4 +-
 .../op/linalg/LoadAndRemapMatrix.java         |  4 +-
 .../op/linalg/LogMatrixDeterminant.java       |  4 +-
 .../gen/java/org/tensorflow/op/linalg/Lu.java |  4 +-
 .../java/org/tensorflow/op/linalg/MatMul.java |  4 +-
 .../org/tensorflow/op/linalg/MatrixDiag.java  |  4 +-
 .../tensorflow/op/linalg/MatrixDiagPart.java  |  4 +-
 .../tensorflow/op/linalg/MatrixLogarithm.java |  4 +-
 .../tensorflow/op/linalg/MatrixSetDiag.java   |  4 +-
 .../tensorflow/op/linalg/MatrixSolveLs.java   |  4 +-
 .../gen/java/org/tensorflow/op/linalg/Qr.java |  4 +-
 .../tensorflow/op/linalg/QuantizedMatMul.java |  4 +-
 .../op/linalg/QuantizedMatMulWithBias.java    |  4 +-
 .../QuantizedMatMulWithBiasAndRelu.java       |  4 +-
 ...zedMatMulWithBiasAndReluAndRequantize.java |  4 +-
 .../tensorflow/op/linalg/SelfAdjointEig.java  |  4 +-
 .../java/org/tensorflow/op/linalg/Solve.java  |  4 +-
 .../java/org/tensorflow/op/linalg/Sqrtm.java  |  4 +-
 .../java/org/tensorflow/op/linalg/Svd.java    |  4 +-
 .../org/tensorflow/op/linalg/TensorDiag.java  |  4 +-
 .../tensorflow/op/linalg/TensorDiagPart.java  |  4 +-
 .../org/tensorflow/op/linalg/Transpose.java   |  4 +-
 .../tensorflow/op/linalg/TriangularSolve.java |  4 +-
 .../op/linalg/TridiagonalMatMul.java          |  4 +-
 .../op/linalg/TridiagonalSolve.java           |  4 +-
 .../sparse/CSRSparseMatrixComponents.java     |  4 +-
 .../linalg/sparse/CSRSparseMatrixToDense.java |  4 +-
 .../sparse/CSRSparseMatrixToSparseTensor.java |  4 +-
 .../linalg/sparse/DenseToCSRSparseMatrix.java |  4 +-
 .../op/linalg/sparse/SparseMatrixAdd.java     |  4 +-
 .../op/linalg/sparse/SparseMatrixMatMul.java  |  4 +-
 .../op/linalg/sparse/SparseMatrixMul.java     |  4 +-
 .../op/linalg/sparse/SparseMatrixNNZ.java     |  4 +-
 .../sparse/SparseMatrixOrderingAMD.java       |  4 +-
 .../op/linalg/sparse/SparseMatrixSoftmax.java |  4 +-
 .../sparse/SparseMatrixSoftmaxGrad.java       |  4 +-
 .../sparse/SparseMatrixSparseCholesky.java    |  4 +-
 .../sparse/SparseMatrixSparseMatMul.java      |  4 +-
 .../linalg/sparse/SparseMatrixTranspose.java  |  4 +-
 .../op/linalg/sparse/SparseMatrixZeros.java   |  4 +-
 .../sparse/SparseTensorToCSRSparseMatrix.java |  4 +-
 .../gen/java/org/tensorflow/op/math/Abs.java  |  4 +-
 .../org/tensorflow/op/math/AccumulateN.java   |  4 +-
 .../gen/java/org/tensorflow/op/math/Acos.java |  4 +-
 .../java/org/tensorflow/op/math/Acosh.java    |  4 +-
 .../gen/java/org/tensorflow/op/math/Add.java  |  4 +-
 .../gen/java/org/tensorflow/op/math/AddN.java |  4 +-
 .../java/org/tensorflow/op/math/Angle.java    |  4 +-
 .../tensorflow/op/math/ApproximateEqual.java  |  4 +-
 .../java/org/tensorflow/op/math/ArgMax.java   |  4 +-
 .../java/org/tensorflow/op/math/ArgMin.java   |  4 +-
 .../gen/java/org/tensorflow/op/math/Asin.java |  4 +-
 .../java/org/tensorflow/op/math/Asinh.java    |  4 +-
 .../gen/java/org/tensorflow/op/math/Atan.java |  4 +-
 .../java/org/tensorflow/op/math/Atan2.java    |  4 +-
 .../java/org/tensorflow/op/math/Atanh.java    |  4 +-
 .../org/tensorflow/op/math/BesselI0e.java     |  4 +-
 .../org/tensorflow/op/math/BesselI1e.java     |  4 +-
 .../java/org/tensorflow/op/math/Betainc.java  |  4 +-
 .../java/org/tensorflow/op/math/Bincount.java |  4 +-
 .../gen/java/org/tensorflow/op/math/Ceil.java |  4 +-
 .../org/tensorflow/op/math/CheckNumerics.java |  4 +-
 .../tensorflow/op/math/CompareAndBitpack.java |  4 +-
 .../org/tensorflow/op/math/ComplexAbs.java    |  4 +-
 .../gen/java/org/tensorflow/op/math/Conj.java |  4 +-
 .../gen/java/org/tensorflow/op/math/Cos.java  |  4 +-
 .../gen/java/org/tensorflow/op/math/Cosh.java |  4 +-
 .../java/org/tensorflow/op/math/Cumprod.java  |  4 +-
 .../java/org/tensorflow/op/math/Cumsum.java   |  4 +-
 .../op/math/CumulativeLogsumexp.java          |  4 +-
 .../java/org/tensorflow/op/math/Digamma.java  |  4 +-
 .../gen/java/org/tensorflow/op/math/Div.java  |  4 +-
 .../java/org/tensorflow/op/math/DivNoNan.java |  4 +-
 .../java/org/tensorflow/op/math/Equal.java    |  4 +-
 .../gen/java/org/tensorflow/op/math/Erf.java  |  4 +-
 .../gen/java/org/tensorflow/op/math/Erfc.java |  4 +-
 .../gen/java/org/tensorflow/op/math/Exp.java  |  4 +-
 .../java/org/tensorflow/op/math/Expm1.java    |  4 +-
 .../gen/java/org/tensorflow/op/math/Fact.java |  4 +-
 .../java/org/tensorflow/op/math/Floor.java    |  4 +-
 .../java/org/tensorflow/op/math/FloorDiv.java |  4 +-
 .../java/org/tensorflow/op/math/FloorMod.java |  4 +-
 .../java/org/tensorflow/op/math/Greater.java  |  4 +-
 .../org/tensorflow/op/math/GreaterEqual.java  |  4 +-
 .../java/org/tensorflow/op/math/Igamma.java   |  4 +-
 .../org/tensorflow/op/math/IgammaGradA.java   |  4 +-
 .../java/org/tensorflow/op/math/Igammac.java  |  4 +-
 .../gen/java/org/tensorflow/op/math/Imag.java |  4 +-
 .../tensorflow/op/math/InvertPermutation.java |  4 +-
 .../java/org/tensorflow/op/math/IsFinite.java |  4 +-
 .../java/org/tensorflow/op/math/IsInf.java    |  4 +-
 .../java/org/tensorflow/op/math/IsNan.java    |  4 +-
 .../gen/java/org/tensorflow/op/math/Less.java |  4 +-
 .../org/tensorflow/op/math/LessEqual.java     |  4 +-
 .../java/org/tensorflow/op/math/Lgamma.java   |  4 +-
 .../gen/java/org/tensorflow/op/math/Log.java  |  4 +-
 .../java/org/tensorflow/op/math/Log1p.java    |  4 +-
 .../org/tensorflow/op/math/LogicalAnd.java    |  4 +-
 .../org/tensorflow/op/math/LogicalNot.java    |  4 +-
 .../org/tensorflow/op/math/LogicalOr.java     |  4 +-
 .../java/org/tensorflow/op/math/Maximum.java  |  4 +-
 .../gen/java/org/tensorflow/op/math/Mean.java |  4 +-
 .../java/org/tensorflow/op/math/Minimum.java  |  4 +-
 .../gen/java/org/tensorflow/op/math/Mod.java  |  4 +-
 .../gen/java/org/tensorflow/op/math/Mul.java  |  4 +-
 .../java/org/tensorflow/op/math/MulNoNan.java |  4 +-
 .../java/org/tensorflow/op/math/Ndtri.java    |  4 +-
 .../gen/java/org/tensorflow/op/math/Neg.java  |  4 +-
 .../org/tensorflow/op/math/NextAfter.java     |  4 +-
 .../java/org/tensorflow/op/math/NotEqual.java |  4 +-
 .../org/tensorflow/op/math/Polygamma.java     |  4 +-
 .../tensorflow/op/math/PopulationCount.java   |  4 +-
 .../gen/java/org/tensorflow/op/math/Pow.java  |  4 +-
 .../org/tensorflow/op/math/QuantizedAdd.java  |  4 +-
 .../org/tensorflow/op/math/QuantizedMul.java  |  4 +-
 .../gen/java/org/tensorflow/op/math/Real.java |  4 +-
 .../java/org/tensorflow/op/math/RealDiv.java  |  4 +-
 .../org/tensorflow/op/math/Reciprocal.java    |  4 +-
 .../tensorflow/op/math/ReciprocalGrad.java    |  4 +-
 .../math/RequantizationRangePerChannel.java   |  4 +-
 .../op/math/RequantizePerChannel.java         |  4 +-
 .../gen/java/org/tensorflow/op/math/Rint.java |  4 +-
 .../java/org/tensorflow/op/math/Round.java    |  4 +-
 .../java/org/tensorflow/op/math/Rsqrt.java    |  4 +-
 .../org/tensorflow/op/math/RsqrtGrad.java     |  4 +-
 .../org/tensorflow/op/math/SegmentMax.java    |  4 +-
 .../org/tensorflow/op/math/SegmentMean.java   |  4 +-
 .../org/tensorflow/op/math/SegmentMin.java    |  4 +-
 .../org/tensorflow/op/math/SegmentProd.java   |  4 +-
 .../org/tensorflow/op/math/SegmentSum.java    |  4 +-
 .../java/org/tensorflow/op/math/Sigmoid.java  |  4 +-
 .../org/tensorflow/op/math/SigmoidGrad.java   |  4 +-
 .../gen/java/org/tensorflow/op/math/Sign.java |  4 +-
 .../gen/java/org/tensorflow/op/math/Sin.java  |  4 +-
 .../gen/java/org/tensorflow/op/math/Sinh.java |  4 +-
 .../java/org/tensorflow/op/math/Softplus.java |  4 +-
 .../org/tensorflow/op/math/SoftplusGrad.java  |  4 +-
 .../gen/java/org/tensorflow/op/math/Sqrt.java |  4 +-
 .../java/org/tensorflow/op/math/SqrtGrad.java |  4 +-
 .../java/org/tensorflow/op/math/Square.java   |  4 +-
 .../tensorflow/op/math/SquaredDifference.java |  4 +-
 .../gen/java/org/tensorflow/op/math/Sub.java  |  4 +-
 .../gen/java/org/tensorflow/op/math/Tan.java  |  4 +-
 .../gen/java/org/tensorflow/op/math/Tanh.java |  4 +-
 .../java/org/tensorflow/op/math/TanhGrad.java |  4 +-
 .../org/tensorflow/op/math/TruncateDiv.java   |  4 +-
 .../org/tensorflow/op/math/TruncateMod.java   |  4 +-
 .../op/math/UnsortedSegmentMax.java           |  4 +-
 .../op/math/UnsortedSegmentMin.java           |  4 +-
 .../op/math/UnsortedSegmentProd.java          |  4 +-
 .../op/math/UnsortedSegmentSum.java           |  4 +-
 .../java/org/tensorflow/op/math/Xdivy.java    |  4 +-
 .../java/org/tensorflow/op/math/Xlogy.java    |  4 +-
 .../gen/java/org/tensorflow/op/math/Zeta.java |  4 +-
 .../java/org/tensorflow/op/math/erfinv.java   |  4 +-
 .../java/org/tensorflow/op/nn/AvgPool.java    |  4 +-
 .../java/org/tensorflow/op/nn/AvgPool3d.java  |  4 +-
 .../org/tensorflow/op/nn/AvgPool3dGrad.java   |  4 +-
 .../org/tensorflow/op/nn/AvgPoolGrad.java     |  4 +-
 .../nn/BatchNormWithGlobalNormalization.java  |  4 +-
 .../BatchNormWithGlobalNormalizationGrad.java |  4 +-
 .../java/org/tensorflow/op/nn/BiasAdd.java    |  4 +-
 .../org/tensorflow/op/nn/BiasAddGrad.java     |  4 +-
 .../java/org/tensorflow/op/nn/BlockLSTM.java  |  4 +-
 .../org/tensorflow/op/nn/BlockLSTMGrad.java   |  4 +-
 .../op/nn/ComputeAccidentalHits.java          |  4 +-
 .../gen/java/org/tensorflow/op/nn/Conv2d.java |  4 +-
 .../op/nn/Conv2dBackpropFilter.java           |  4 +-
 .../tensorflow/op/nn/Conv2dBackpropInput.java |  4 +-
 .../gen/java/org/tensorflow/op/nn/Conv3d.java |  4 +-
 .../op/nn/Conv3dBackpropFilter.java           |  4 +-
 .../tensorflow/op/nn/Conv3dBackpropInput.java |  4 +-
 .../op/nn/CtcBeamSearchDecoder.java           |  4 +-
 .../tensorflow/op/nn/CtcGreedyDecoder.java    |  4 +-
 .../java/org/tensorflow/op/nn/CtcLoss.java    |  4 +-
 .../java/org/tensorflow/op/nn/CudnnRNN.java   |  4 +-
 .../tensorflow/op/nn/CudnnRNNBackprop.java    |  4 +-
 .../op/nn/CudnnRNNCanonicalToParams.java      |  4 +-
 .../op/nn/CudnnRNNParamsToCanonical.java      |  4 +-
 .../tensorflow/op/nn/CudnnRnnParamsSize.java  |  4 +-
 .../tensorflow/op/nn/DataFormatDimMap.java    |  4 +-
 .../op/nn/DataFormatVecPermute.java           |  4 +-
 .../org/tensorflow/op/nn/DepthToSpace.java    |  4 +-
 .../op/nn/DepthwiseConv2dNative.java          |  4 +-
 .../DepthwiseConv2dNativeBackpropFilter.java  |  4 +-
 .../DepthwiseConv2dNativeBackpropInput.java   |  4 +-
 .../java/org/tensorflow/op/nn/Dilation2d.java |  4 +-
 .../op/nn/Dilation2dBackpropFilter.java       |  4 +-
 .../op/nn/Dilation2dBackpropInput.java        |  4 +-
 .../gen/java/org/tensorflow/op/nn/Elu.java    |  4 +-
 .../java/org/tensorflow/op/nn/EluGrad.java    |  4 +-
 .../op/nn/FixedUnigramCandidateSampler.java   |  4 +-
 .../tensorflow/op/nn/FractionalAvgPool.java   |  4 +-
 .../op/nn/FractionalAvgPoolGrad.java          |  4 +-
 .../tensorflow/op/nn/FractionalMaxPool.java   |  4 +-
 .../op/nn/FractionalMaxPoolGrad.java          |  4 +-
 .../org/tensorflow/op/nn/FusedBatchNorm.java  |  4 +-
 .../tensorflow/op/nn/FusedBatchNormGrad.java  |  4 +-
 .../org/tensorflow/op/nn/FusedPadConv2d.java  |  4 +-
 .../op/nn/FusedResizeAndPadConv2d.java        |  4 +-
 .../org/tensorflow/op/nn/GRUBlockCell.java    |  4 +-
 .../tensorflow/op/nn/GRUBlockCellGrad.java    |  4 +-
 .../gen/java/org/tensorflow/op/nn/InTopK.java |  4 +-
 .../java/org/tensorflow/op/nn/InvGrad.java    |  4 +-
 .../gen/java/org/tensorflow/op/nn/L2Loss.java |  4 +-
 .../org/tensorflow/op/nn/LSTMBlockCell.java   |  4 +-
 .../tensorflow/op/nn/LSTMBlockCellGrad.java   |  4 +-
 .../java/org/tensorflow/op/nn/LeakyRelu.java  |  4 +-
 .../op/nn/LearnedUnigramCandidateSampler.java |  4 +-
 .../op/nn/LocalResponseNormalization.java     |  4 +-
 .../op/nn/LocalResponseNormalizationGrad.java |  4 +-
 .../java/org/tensorflow/op/nn/LogSoftmax.java |  4 +-
 .../java/org/tensorflow/op/nn/MaxPool.java    |  4 +-
 .../java/org/tensorflow/op/nn/MaxPool3d.java  |  4 +-
 .../org/tensorflow/op/nn/MaxPool3dGrad.java   |  4 +-
 .../tensorflow/op/nn/MaxPool3dGradGrad.java   |  4 +-
 .../org/tensorflow/op/nn/MaxPoolGrad.java     |  4 +-
 .../org/tensorflow/op/nn/MaxPoolGradGrad.java |  4 +-
 .../op/nn/MaxPoolGradGradWithArgmax.java      |  4 +-
 .../op/nn/MaxPoolGradWithArgmax.java          |  4 +-
 .../tensorflow/op/nn/MaxPoolWithArgmax.java   |  4 +-
 .../java/org/tensorflow/op/nn/NthElement.java |  4 +-
 .../tensorflow/op/nn/QuantizedAvgPool.java    |  4 +-
 ...tizedBatchNormWithGlobalNormalization.java |  4 +-
 .../tensorflow/op/nn/QuantizedBiasAdd.java    |  4 +-
 .../op/nn/QuantizedConv2DAndRelu.java         |  4 +-
 .../QuantizedConv2DAndReluAndRequantize.java  |  4 +-
 .../op/nn/QuantizedConv2DAndRequantize.java   |  4 +-
 .../op/nn/QuantizedConv2DPerChannel.java      |  4 +-
 .../op/nn/QuantizedConv2DWithBias.java        |  4 +-
 .../op/nn/QuantizedConv2DWithBiasAndRelu.java |  4 +-
 ...zedConv2DWithBiasAndReluAndRequantize.java |  4 +-
 .../QuantizedConv2DWithBiasAndRequantize.java |  4 +-
 ...WithBiasSignedSumAndReluAndRequantize.java |  4 +-
 .../nn/QuantizedConv2DWithBiasSumAndRelu.java |  4 +-
 ...Conv2DWithBiasSumAndReluAndRequantize.java |  4 +-
 .../org/tensorflow/op/nn/QuantizedConv2d.java |  4 +-
 .../op/nn/QuantizedDepthwiseConv2D.java       |  4 +-
 .../nn/QuantizedDepthwiseConv2DWithBias.java  |  4 +-
 ...antizedDepthwiseConv2DWithBiasAndRelu.java |  4 +-
 ...iseConv2DWithBiasAndReluAndRequantize.java |  4 +-
 .../op/nn/QuantizedInstanceNorm.java          |  4 +-
 .../tensorflow/op/nn/QuantizedMaxPool.java    |  4 +-
 .../org/tensorflow/op/nn/QuantizedRelu.java   |  4 +-
 .../org/tensorflow/op/nn/QuantizedRelu6.java  |  4 +-
 .../org/tensorflow/op/nn/QuantizedReluX.java  |  4 +-
 .../gen/java/org/tensorflow/op/nn/Relu.java   |  4 +-
 .../gen/java/org/tensorflow/op/nn/Relu6.java  |  4 +-
 .../java/org/tensorflow/op/nn/Relu6Grad.java  |  4 +-
 .../java/org/tensorflow/op/nn/ReluGrad.java   |  4 +-
 .../gen/java/org/tensorflow/op/nn/Selu.java   |  4 +-
 .../java/org/tensorflow/op/nn/SeluGrad.java   |  4 +-
 .../java/org/tensorflow/op/nn/Softmax.java    |  4 +-
 .../op/nn/SoftmaxCrossEntropyWithLogits.java  |  4 +-
 .../java/org/tensorflow/op/nn/Softsign.java   |  4 +-
 .../org/tensorflow/op/nn/SoftsignGrad.java    |  4 +-
 .../org/tensorflow/op/nn/SpaceToBatch.java    |  4 +-
 .../org/tensorflow/op/nn/SpaceToDepth.java    |  4 +-
 .../SparseSoftmaxCrossEntropyWithLogits.java  |  4 +-
 .../gen/java/org/tensorflow/op/nn/TopK.java   |  4 +-
 .../op/quantization/Dequantize.java           |  4 +-
 .../quantization/FakeQuantWithMinMaxArgs.java |  4 +-
 .../FakeQuantWithMinMaxArgsGradient.java      |  4 +-
 .../quantization/FakeQuantWithMinMaxVars.java |  4 +-
 .../FakeQuantWithMinMaxVarsGradient.java      |  4 +-
 .../FakeQuantWithMinMaxVarsPerChannel.java    |  4 +-
 ...QuantWithMinMaxVarsPerChannelGradient.java |  4 +-
 .../tensorflow/op/quantization/Quantize.java  |  4 +-
 .../quantization/QuantizeAndDequantize.java   |  4 +-
 .../QuantizeDownAndShrinkRange.java           |  4 +-
 .../op/quantization/QuantizedConcat.java      |  4 +-
 .../op/quantization/RequantizationRange.java  |  4 +-
 .../op/quantization/Requantize.java           |  4 +-
 .../tensorflow/op/ragged/RaggedGather.java    |  4 +-
 .../org/tensorflow/op/ragged/RaggedRange.java |  4 +-
 .../op/ragged/RaggedTensorFromVariant.java    |  4 +-
 .../op/ragged/RaggedTensorToSparse.java       |  4 +-
 .../op/ragged/RaggedTensorToTensor.java       |  4 +-
 .../op/ragged/RaggedTensorToVariant.java      |  4 +-
 .../op/random/AllCandidateSampler.java        |  4 +-
 .../random/AnonymousRandomSeedGenerator.java  |  4 +-
 .../op/random/DeleteRandomSeedGenerator.java  |  4 +-
 .../op/random/LogUniformCandidateSampler.java |  4 +-
 .../org/tensorflow/op/random/Multinomial.java |  4 +-
 .../op/random/NonDeterministicInts.java       |  4 +-
 .../random/ParameterizedTruncatedNormal.java  |  4 +-
 .../org/tensorflow/op/random/RandomGamma.java |  4 +-
 .../tensorflow/op/random/RandomGammaGrad.java |  4 +-
 .../tensorflow/op/random/RandomPoisson.java   |  4 +-
 .../tensorflow/op/random/RandomShuffle.java   |  4 +-
 .../op/random/RandomStandardNormal.java       |  4 +-
 .../tensorflow/op/random/RandomUniform.java   |  4 +-
 .../op/random/RandomUniformInt.java           |  4 +-
 .../org/tensorflow/op/random/RecordInput.java |  4 +-
 .../org/tensorflow/op/random/RngSkip.java     |  4 +-
 .../op/random/StatefulRandomBinomial.java     |  4 +-
 .../op/random/StatefulStandardNormal.java     |  4 +-
 .../op/random/StatefulTruncatedNormal.java    |  4 +-
 .../tensorflow/op/random/StatefulUniform.java |  4 +-
 .../op/random/StatefulUniformFullInt.java     |  4 +-
 .../op/random/StatefulUniformInt.java         |  4 +-
 .../op/random/StatelessMultinomial.java       |  4 +-
 .../op/random/StatelessRandomNormal.java      |  4 +-
 .../op/random/StatelessRandomUniform.java     |  4 +-
 .../op/random/StatelessRandomUniformInt.java  |  4 +-
 .../op/random/StatelessTruncatedNormal.java   |  4 +-
 .../tensorflow/op/random/TruncatedNormal.java |  4 +-
 .../op/random/UniformCandidateSampler.java    |  4 +-
 .../org/tensorflow/op/signal/BatchFft.java    |  4 +-
 .../org/tensorflow/op/signal/BatchFft2d.java  |  4 +-
 .../org/tensorflow/op/signal/BatchFft3d.java  |  4 +-
 .../org/tensorflow/op/signal/BatchIfft.java   |  4 +-
 .../org/tensorflow/op/signal/BatchIfft2d.java |  4 +-
 .../org/tensorflow/op/signal/BatchIfft3d.java |  4 +-
 .../java/org/tensorflow/op/signal/Fft.java    |  4 +-
 .../java/org/tensorflow/op/signal/Fft2d.java  |  4 +-
 .../java/org/tensorflow/op/signal/Fft3d.java  |  4 +-
 .../java/org/tensorflow/op/signal/Ifft.java   |  4 +-
 .../java/org/tensorflow/op/signal/Ifft2d.java |  4 +-
 .../java/org/tensorflow/op/signal/Ifft3d.java |  4 +-
 .../java/org/tensorflow/op/signal/Irfft.java  |  4 +-
 .../org/tensorflow/op/signal/Irfft2d.java     |  4 +-
 .../org/tensorflow/op/signal/Irfft3d.java     |  4 +-
 .../java/org/tensorflow/op/signal/Rfft.java   |  4 +-
 .../java/org/tensorflow/op/signal/Rfft2d.java |  4 +-
 .../java/org/tensorflow/op/signal/Rfft3d.java |  4 +-
 .../op/sparse/AddManySparseToTensorsMap.java  |  4 +-
 .../op/sparse/AddSparseToTensorsMap.java      |  4 +-
 .../op/sparse/DenseToDenseSetOperation.java   |  4 +-
 .../op/sparse/DenseToSparseSetOperation.java  |  4 +-
 .../op/sparse/DeserializeSparse.java          |  4 +-
 .../SparseAccumulatorApplyGradient.java       |  4 +-
 .../sparse/SparseAccumulatorTakeGradient.java |  4 +-
 .../org/tensorflow/op/sparse/SparseAdd.java   |  4 +-
 .../tensorflow/op/sparse/SparseAddGrad.java   |  4 +-
 .../tensorflow/op/sparse/SparseConcat.java    |  4 +-
 .../sparse/SparseConditionalAccumulator.java  |  4 +-
 .../org/tensorflow/op/sparse/SparseCross.java |  4 +-
 .../op/sparse/SparseDenseCwiseAdd.java        |  4 +-
 .../op/sparse/SparseDenseCwiseDiv.java        |  4 +-
 .../op/sparse/SparseDenseCwiseMul.java        |  4 +-
 .../op/sparse/SparseFillEmptyRows.java        |  4 +-
 .../op/sparse/SparseFillEmptyRowsGrad.java    |  4 +-
 .../tensorflow/op/sparse/SparseMatMul.java    |  4 +-
 .../tensorflow/op/sparse/SparseReduceMax.java |  4 +-
 .../op/sparse/SparseReduceMaxSparse.java      |  4 +-
 .../tensorflow/op/sparse/SparseReduceSum.java |  4 +-
 .../op/sparse/SparseReduceSumSparse.java      |  4 +-
 .../tensorflow/op/sparse/SparseReorder.java   |  4 +-
 .../tensorflow/op/sparse/SparseReshape.java   |  4 +-
 .../op/sparse/SparseSegmentMean.java          |  4 +-
 .../op/sparse/SparseSegmentMeanGrad.java      |  4 +-
 .../SparseSegmentMeanWithNumSegments.java     |  4 +-
 .../op/sparse/SparseSegmentSqrtN.java         |  4 +-
 .../op/sparse/SparseSegmentSqrtNGrad.java     |  4 +-
 .../SparseSegmentSqrtNWithNumSegments.java    |  4 +-
 .../op/sparse/SparseSegmentSum.java           |  4 +-
 .../SparseSegmentSumWithNumSegments.java      |  4 +-
 .../org/tensorflow/op/sparse/SparseSlice.java |  4 +-
 .../tensorflow/op/sparse/SparseSliceGrad.java |  4 +-
 .../tensorflow/op/sparse/SparseSoftmax.java   |  4 +-
 .../op/sparse/SparseSparseMaximum.java        |  4 +-
 .../op/sparse/SparseSparseMinimum.java        |  4 +-
 .../org/tensorflow/op/sparse/SparseSplit.java |  4 +-
 .../op/sparse/SparseTensorDenseAdd.java       |  4 +-
 .../op/sparse/SparseTensorDenseMatMul.java    |  4 +-
 .../tensorflow/op/sparse/SparseToDense.java   |  4 +-
 .../op/sparse/SparseToSparseSetOperation.java |  4 +-
 .../sparse/TakeManySparseFromTensorsMap.java  |  4 +-
 .../java/org/tensorflow/op/strings/Join.java  |  4 +-
 .../java/org/tensorflow/op/strings/Lower.java |  4 +-
 .../org/tensorflow/op/strings/ReduceJoin.java |  4 +-
 .../tensorflow/op/strings/RegexFullMatch.java |  4 +-
 .../tensorflow/op/strings/RegexReplace.java   |  4 +-
 .../op/strings/StaticRegexFullMatch.java      |  4 +-
 .../op/strings/StaticRegexReplace.java        |  4 +-
 .../tensorflow/op/strings/StringFormat.java   |  4 +-
 .../tensorflow/op/strings/StringLength.java   |  4 +-
 .../tensorflow/op/strings/StringNGrams.java   |  4 +-
 .../tensorflow/op/strings/StringSplit.java    |  4 +-
 .../java/org/tensorflow/op/strings/Strip.java |  4 +-
 .../org/tensorflow/op/strings/Substr.java     |  4 +-
 .../tensorflow/op/strings/ToHashBucket.java   |  4 +-
 .../op/strings/ToHashBucketFast.java          |  4 +-
 .../op/strings/ToHashBucketStrong.java        |  4 +-
 .../org/tensorflow/op/strings/ToNumber.java   |  4 +-
 .../tensorflow/op/strings/UnicodeDecode.java  |  4 +-
 .../op/strings/UnicodeDecodeWithOffsets.java  |  4 +-
 .../tensorflow/op/strings/UnicodeEncode.java  |  4 +-
 .../tensorflow/op/strings/UnicodeScript.java  |  4 +-
 .../op/strings/UnicodeTranscode.java          |  4 +-
 .../op/strings/UnsortedSegmentJoin.java       |  4 +-
 .../java/org/tensorflow/op/strings/Upper.java |  4 +-
 .../tensorflow/op/summary/AudioSummary.java   |  4 +-
 .../op/summary/CloseSummaryWriter.java        |  4 +-
 .../op/summary/CreateSummaryDbWriter.java     |  4 +-
 .../op/summary/CreateSummaryFileWriter.java   |  4 +-
 .../op/summary/FlushSummaryWriter.java        |  4 +-
 .../op/summary/HistogramSummary.java          |  4 +-
 .../tensorflow/op/summary/ImageSummary.java   |  4 +-
 .../tensorflow/op/summary/ImportEvent.java    |  4 +-
 .../tensorflow/op/summary/MergeSummary.java   |  4 +-
 .../tensorflow/op/summary/ScalarSummary.java  |  4 +-
 .../op/summary/StatsAggregatorSummary.java    |  4 +-
 .../tensorflow/op/summary/SummaryWriter.java  |  4 +-
 .../tensorflow/op/summary/TensorSummary.java  |  4 +-
 .../op/summary/WriteAudioSummary.java         |  4 +-
 .../op/summary/WriteGraphSummary.java         |  4 +-
 .../op/summary/WriteHistogramSummary.java     |  4 +-
 .../op/summary/WriteImageSummary.java         |  4 +-
 .../op/summary/WriteRawProtoSummary.java      |  4 +-
 .../op/summary/WriteScalarSummary.java        |  4 +-
 .../tensorflow/op/summary/WriteSummary.java   |  4 +-
 .../java/org/tensorflow/op/tpu/AllToAll.java  |  4 +-
 .../tensorflow/op/tpu/CollectivePermute.java  |  4 +-
 .../op/tpu/ConfigureDistributedTPU.java       |  4 +-
 .../op/tpu/ConfigureTPUEmbedding.java         |  4 +-
 .../tensorflow/op/tpu/CrossReplicaSum.java    |  4 +-
 .../tpu/EnqueueTPUEmbeddingIntegerBatch.java  |  4 +-
 .../tpu/EnqueueTPUEmbeddingSparseBatch.java   |  4 +-
 .../EnqueueTPUEmbeddingSparseTensorBatch.java |  4 +-
 .../org/tensorflow/op/tpu/InfeedDequeue.java  |  4 +-
 .../tensorflow/op/tpu/InfeedDequeueTuple.java |  4 +-
 .../org/tensorflow/op/tpu/InfeedEnqueue.java  |  4 +-
 .../tpu/InfeedEnqueuePrelinearizedBuffer.java |  4 +-
 .../tensorflow/op/tpu/InfeedEnqueueTuple.java |  4 +-
 .../tpu/LoadTPUEmbeddingADAMParameters.java   |  4 +-
 ...EmbeddingADAMParametersGradAccumDebug.java |  4 +-
 .../LoadTPUEmbeddingAdadeltaParameters.java   |  4 +-
 ...ddingAdadeltaParametersGradAccumDebug.java |  4 +-
 .../LoadTPUEmbeddingAdagradParameters.java    |  4 +-
 ...eddingAdagradParametersGradAccumDebug.java |  4 +-
 ...TPUEmbeddingCenteredRMSPropParameters.java |  4 +-
 .../tpu/LoadTPUEmbeddingFTRLParameters.java   |  4 +-
 ...EmbeddingFTRLParametersGradAccumDebug.java |  4 +-
 ...TPUEmbeddingMDLAdagradLightParameters.java |  4 +-
 .../LoadTPUEmbeddingMomentumParameters.java   |  4 +-
 ...ddingMomentumParametersGradAccumDebug.java |  4 +-
 ...TPUEmbeddingProximalAdagradParameters.java |  4 +-
 ...oximalAdagradParametersGradAccumDebug.java |  4 +-
 .../LoadTPUEmbeddingRMSPropParameters.java    |  4 +-
 ...eddingRMSPropParametersGradAccumDebug.java |  4 +-
 ...ngStochasticGradientDescentParameters.java |  4 +-
 .../org/tensorflow/op/tpu/OutfeedDequeue.java |  4 +-
 .../op/tpu/OutfeedDequeueTuple.java           |  4 +-
 .../org/tensorflow/op/tpu/OutfeedEnqueue.java |  4 +-
 .../op/tpu/OutfeedEnqueueTuple.java           |  4 +-
 .../org/tensorflow/op/tpu/Prelinearize.java   |  4 +-
 .../tensorflow/op/tpu/PrelinearizeTuple.java  |  4 +-
 .../op/tpu/RecvTPUEmbeddingActivations.java   |  4 +-
 .../RetrieveTPUEmbeddingADAMParameters.java   |  4 +-
 ...EmbeddingADAMParametersGradAccumDebug.java |  4 +-
 ...etrieveTPUEmbeddingAdadeltaParameters.java |  4 +-
 ...ddingAdadeltaParametersGradAccumDebug.java |  4 +-
 ...RetrieveTPUEmbeddingAdagradParameters.java |  4 +-
 ...eddingAdagradParametersGradAccumDebug.java |  4 +-
 ...TPUEmbeddingCenteredRMSPropParameters.java |  4 +-
 .../RetrieveTPUEmbeddingFTRLParameters.java   |  4 +-
 ...EmbeddingFTRLParametersGradAccumDebug.java |  4 +-
 ...TPUEmbeddingMDLAdagradLightParameters.java |  4 +-
 ...etrieveTPUEmbeddingMomentumParameters.java |  4 +-
 ...ddingMomentumParametersGradAccumDebug.java |  4 +-
 ...TPUEmbeddingProximalAdagradParameters.java |  4 +-
 ...oximalAdagradParametersGradAccumDebug.java |  4 +-
 ...RetrieveTPUEmbeddingRMSPropParameters.java |  4 +-
 ...eddingRMSPropParametersGradAccumDebug.java |  4 +-
 ...ngStochasticGradientDescentParameters.java |  4 +-
 .../op/tpu/SendTPUEmbeddingGradients.java     |  4 +-
 .../op/tpu/ShutdownDistributedTPU.java        |  4 +-
 .../op/tpu/TPUCompilationResult.java          |  4 +-
 .../op/tpu/TPUEmbeddingActivations.java       |  4 +-
 .../tensorflow/op/tpu/TPUOrdinalSelector.java |  4 +-
 .../op/tpu/TPUReplicateMetadata.java          |  4 +-
 .../tensorflow/op/tpu/TPUReplicatedInput.java |  4 +-
 .../op/tpu/TPUReplicatedOutput.java           |  4 +-
 .../tensorflow/op/tpu/WorkerHeartbeat.java    |  4 +-
 .../op/train/AccumulatorApplyGradient.java    |  4 +-
 .../op/train/AccumulatorNumAccumulated.java   |  4 +-
 .../op/train/AccumulatorSetGlobalStep.java    |  4 +-
 .../op/train/AccumulatorTakeGradient.java     |  4 +-
 .../org/tensorflow/op/train/ApplyAdaMax.java  |  4 +-
 .../tensorflow/op/train/ApplyAdadelta.java    |  4 +-
 .../org/tensorflow/op/train/ApplyAdagrad.java |  4 +-
 .../tensorflow/op/train/ApplyAdagradDa.java   |  4 +-
 .../tensorflow/op/train/ApplyAdagradV2.java   |  4 +-
 .../org/tensorflow/op/train/ApplyAdam.java    |  4 +-
 .../org/tensorflow/op/train/ApplyAddSign.java |  4 +-
 .../op/train/ApplyCenteredRmsProp.java        |  4 +-
 .../org/tensorflow/op/train/ApplyFtrl.java    |  4 +-
 .../op/train/ApplyGradientDescent.java        |  4 +-
 .../tensorflow/op/train/ApplyMomentum.java    |  4 +-
 .../tensorflow/op/train/ApplyPowerSign.java   |  4 +-
 .../op/train/ApplyProximalAdagrad.java        |  4 +-
 .../train/ApplyProximalGradientDescent.java   |  4 +-
 .../org/tensorflow/op/train/ApplyRmsProp.java |  4 +-
 .../org/tensorflow/op/train/BatchMatMul.java  |  4 +-
 .../op/train/ConditionalAccumulator.java      |  4 +-
 .../op/train/GenerateVocabRemapping.java      |  4 +-
 .../op/train/MergeV2Checkpoints.java          |  4 +-
 .../org/tensorflow/op/train/NegTrain.java     |  4 +-
 .../tensorflow/op/train/PreventGradient.java  |  4 +-
 .../ResourceAccumulatorApplyGradient.java     |  4 +-
 .../ResourceAccumulatorNumAccumulated.java    |  4 +-
 .../ResourceAccumulatorSetGlobalStep.java     |  4 +-
 .../ResourceAccumulatorTakeGradient.java      |  4 +-
 .../op/train/ResourceApplyAdaMax.java         |  4 +-
 .../op/train/ResourceApplyAdadelta.java       |  4 +-
 .../op/train/ResourceApplyAdagrad.java        |  4 +-
 .../op/train/ResourceApplyAdagradDa.java      |  4 +-
 .../op/train/ResourceApplyAdam.java           |  4 +-
 .../train/ResourceApplyAdamWithAmsgrad.java   |  4 +-
 .../op/train/ResourceApplyAddSign.java        |  4 +-
 .../train/ResourceApplyCenteredRmsProp.java   |  4 +-
 .../op/train/ResourceApplyFtrl.java           |  4 +-
 .../train/ResourceApplyGradientDescent.java   |  4 +-
 .../op/train/ResourceApplyKerasMomentum.java  |  4 +-
 .../op/train/ResourceApplyMomentum.java       |  4 +-
 .../op/train/ResourceApplyPowerSign.java      |  4 +-
 .../train/ResourceApplyProximalAdagrad.java   |  4 +-
 .../ResourceApplyProximalGradientDescent.java |  4 +-
 .../op/train/ResourceApplyRmsProp.java        |  4 +-
 .../train/ResourceConditionalAccumulator.java |  4 +-
 .../op/train/ResourceSparseApplyAdadelta.java |  4 +-
 .../op/train/ResourceSparseApplyAdagrad.java  |  4 +-
 .../train/ResourceSparseApplyAdagradDa.java   |  4 +-
 .../train/ResourceSparseApplyAdagradV2.java   |  4 +-
 .../ResourceSparseApplyCenteredRmsProp.java   |  4 +-
 .../op/train/ResourceSparseApplyFtrl.java     |  4 +-
 .../ResourceSparseApplyKerasMomentum.java     |  4 +-
 .../op/train/ResourceSparseApplyMomentum.java |  4 +-
 .../ResourceSparseApplyProximalAdagrad.java   |  4 +-
 ...rceSparseApplyProximalGradientDescent.java |  4 +-
 .../op/train/ResourceSparseApplyRmsProp.java  |  4 +-
 .../java/org/tensorflow/op/train/Restore.java |  4 +-
 .../org/tensorflow/op/train/RestoreSlice.java |  4 +-
 .../java/org/tensorflow/op/train/Save.java    |  4 +-
 .../org/tensorflow/op/train/SaveSlices.java   |  4 +-
 .../org/tensorflow/op/train/SdcaFprint.java   |  4 +-
 .../tensorflow/op/train/SdcaOptimizer.java    |  4 +-
 .../org/tensorflow/op/train/SdcaShrinkL1.java |  4 +-
 .../op/train/SparseApplyAdadelta.java         |  4 +-
 .../op/train/SparseApplyAdagrad.java          |  4 +-
 .../op/train/SparseApplyAdagradDa.java        |  4 +-
 .../op/train/SparseApplyCenteredRmsProp.java  |  4 +-
 .../tensorflow/op/train/SparseApplyFtrl.java  |  4 +-
 .../op/train/SparseApplyMomentum.java         |  4 +-
 .../op/train/SparseApplyProximalAdagrad.java  |  4 +-
 .../SparseApplyProximalGradientDescent.java   |  4 +-
 .../op/train/SparseApplyRmsProp.java          |  4 +-
 .../org/tensorflow/op/train/TileGrad.java     |  4 +-
 .../src/main/java/org/tensorflow/Graph.java   |  5 ++-
 .../src/main/java/org/tensorflow/Operand.java |  3 +-
 .../src/main/java/org/tensorflow/Output.java  | 10 ++---
 .../src/main/java/org/tensorflow/op/Op.java   | 44 +++++++++++++------
 .../op/{PrimitiveOp.java => RawOp.java}       | 14 +++---
 .../main/java/org/tensorflow/op/Scope.java    | 11 +++--
 .../tensorflow/op/annotation/Operator.java    |  4 +-
 .../java/org/tensorflow/op/core/Constant.java |  4 +-
 .../org/tensorflow/op/core/Gradients.java     |  2 +-
 .../java/org/tensorflow/op/core/Zeros.java    |  6 +++
 .../{PrimitiveOpTest.java => RawOpTest.java}  | 16 +++----
 .../op/core/GeneratedOperationsTest.java      |  3 +-
 .../processor/operator/OperatorProcessor.java | 13 ++----
 .../training/optimizers/AdaDelta.java         |  3 +-
 .../training/optimizers/AdaGrad.java          |  3 +-
 .../training/optimizers/AdaGradDA.java        |  6 +--
 .../tensorflow/training/optimizers/Adam.java  |  6 +--
 .../training/optimizers/GradientDescent.java  |  4 +-
 .../training/optimizers/Momentum.java         |  3 +-
 .../training/optimizers/Optimizer.java        | 13 +++---
 .../training/optimizers/RMSProp.java          |  3 +-
 1094 files changed, 2244 insertions(+), 2222 deletions(-)
 rename tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/{PrimitiveOp.java => RawOp.java} (77%)
 rename tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/{PrimitiveOpTest.java => RawOpTest.java} (79%)

diff --git a/tensorflow-core/tensorflow-core-api/src/bazel/op_generator/op_generator.cc b/tensorflow-core/tensorflow-core-api/src/bazel/op_generator/op_generator.cc
index 35d498258d0..f0fb802d548 100644
--- a/tensorflow-core/tensorflow-core-api/src/bazel/op_generator/op_generator.cc
+++ b/tensorflow-core/tensorflow-core-api/src/bazel/op_generator/op_generator.cc
@@ -423,7 +423,7 @@ void GenerateOp(const OpSpec& op, const EndpointSpec& endpoint,
                 Env* env) {
   Type op_class(
       ClassOf(endpoint, base_package)
-          .add_supertype(Type::Class("PrimitiveOp", "org.tensorflow.op")));
+          .add_supertype(Type::Class("RawOp", "org.tensorflow.op")));
   Javadoc op_javadoc(endpoint.javadoc());
 
   // op interfaces
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/Ops.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/Ops.java
index ff1ec5e3fab..850bf316db6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/Ops.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/Ops.java
@@ -7519,9 +7519,9 @@ public Ops withName(String opName) {
   /**
    * Returns an API that adds operations to the graph with the provided control dependencies.
    *
-   * @see {@link Scope#withControlDependencies(Iterable<Operand<?>>)}
+   * @see {@link Scope#withControlDependencies(Iterable<Op<?>>)}
    */
-  public Ops withControlDependencies(Iterable<Operand<?>> controls) {
+  public Ops withControlDependencies(Iterable<Op> controls) {
     return new Ops(scope.withControlDependencies(controls));
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/audio/AudioSpectrogram.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/audio/AudioSpectrogram.java
index 027a164fa2a..83251e8e833 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/audio/AudioSpectrogram.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/audio/AudioSpectrogram.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -57,7 +57,7 @@
  * resulting spectrogram as a PNG image.
  */
 @Operator(group = "audio")
-public final class AudioSpectrogram extends PrimitiveOp implements Operand<TFloat32> {
+public final class AudioSpectrogram extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.audio.AudioSpectrogram}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/audio/DecodeWav.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/audio/DecodeWav.java
index 8dc604dc5fa..a58d814660c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/audio/DecodeWav.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/audio/DecodeWav.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * output shape of [10, 2].
  */
 @Operator(group = "audio")
-public final class DecodeWav extends PrimitiveOp {
+public final class DecodeWav extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.audio.DecodeWav}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/audio/EncodeWav.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/audio/EncodeWav.java
index 4162c2f9e97..2336a3124c5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/audio/EncodeWav.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/audio/EncodeWav.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * `sample_rate` is a scalar Tensor holding the rate to use (e.g. 44100).
  */
 @Operator(group = "audio")
-public final class EncodeWav extends PrimitiveOp implements Operand<TString> {
+public final class EncodeWav extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new EncodeWav operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/audio/Mfcc.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/audio/Mfcc.java
index 1765e1b9cd6..a13d22fdb4a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/audio/Mfcc.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/audio/Mfcc.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * is a good resource to learn more.
  */
 @Operator(group = "audio")
-public final class Mfcc extends PrimitiveOp implements Operand<TFloat32> {
+public final class Mfcc extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.audio.Mfcc}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/BitwiseAnd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/BitwiseAnd.java
index 48310fb0f00..70318891190 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/BitwiseAnd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/BitwiseAnd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -54,7 +54,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "bitwise")
-public final class BitwiseAnd<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class BitwiseAnd<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BitwiseAnd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/BitwiseOr.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/BitwiseOr.java
index 1a74faeec56..4d882a6c202 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/BitwiseOr.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/BitwiseOr.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -54,7 +54,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "bitwise")
-public final class BitwiseOr<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class BitwiseOr<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BitwiseOr operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/BitwiseXor.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/BitwiseXor.java
index 0c50b6360df..597ae15fb90 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/BitwiseXor.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/BitwiseXor.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -54,7 +54,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "bitwise")
-public final class BitwiseXor<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class BitwiseXor<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BitwiseXor operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/Invert.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/Invert.java
index 49c4bfe8175..6cbacade24d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/Invert.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/Invert.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -75,7 +75,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "bitwise")
-public final class Invert<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Invert<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Invert operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/LeftShift.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/LeftShift.java
index 028c86cccac..c215b913646 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/LeftShift.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/LeftShift.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -65,7 +65,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "bitwise")
-public final class LeftShift<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class LeftShift<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new LeftShift operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/RightShift.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/RightShift.java
index ecb9dbaf7d0..0344a7779df 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/RightShift.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/bitwise/RightShift.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -68,7 +68,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "bitwise")
-public final class RightShift<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class RightShift<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RightShift operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/cluster/KMC2ChainInitialization.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/cluster/KMC2ChainInitialization.java
index 48f61ae3f2b..350036bbdc6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/cluster/KMC2ChainInitialization.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/cluster/KMC2ChainInitialization.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * of the k-MC^2 algorithm and returns the index of one candidate point to be added
  * as an additional cluster center.
  */
-public final class KMC2ChainInitialization extends PrimitiveOp implements Operand<TInt64> {
+public final class KMC2ChainInitialization extends RawOp implements Operand<TInt64> {
   
   /**
    * Factory method to create a class wrapping a new KMC2ChainInitialization operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/cluster/KmeansPlusPlusInitialization.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/cluster/KmeansPlusPlusInitialization.java
index 404108e07b7..a8d6f3eb70b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/cluster/KmeansPlusPlusInitialization.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/cluster/KmeansPlusPlusInitialization.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * distance from the nearest row selected thus far till num_to_sample rows have
  * been sampled.
  */
-public final class KmeansPlusPlusInitialization extends PrimitiveOp implements Operand<TFloat32> {
+public final class KmeansPlusPlusInitialization extends RawOp implements Operand<TFloat32> {
   
   /**
    * Factory method to create a class wrapping a new KmeansPlusPlusInitialization operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/collective/AllReduce.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/collective/AllReduce.java
index a3dbd73fb7f..40125fa7856 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/collective/AllReduce.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/collective/AllReduce.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class AllReduce<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class AllReduce<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.collective.AllReduce}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/collective/BroadcastRecv.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/collective/BroadcastRecv.java
index 00475e5c47f..3b8867aea1f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/collective/BroadcastRecv.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/collective/BroadcastRecv.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class BroadcastRecv<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class BroadcastRecv<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.collective.BroadcastRecv}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/collective/BroadcastSend.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/collective/BroadcastSend.java
index c7709ac8392..609c477198c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/collective/BroadcastSend.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/collective/BroadcastSend.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class BroadcastSend<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class BroadcastSend<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.collective.BroadcastSend}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Abort.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Abort.java
index 844d483a227..6fde31b3dbc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Abort.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Abort.java
@@ -19,7 +19,7 @@
 
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * Returns nothing but an exception.
  */
 @Operator
-public final class Abort extends PrimitiveOp {
+public final class Abort extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Abort}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/All.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/All.java
index 62103145ad3..2c92e6934cc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/All.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/All.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * retained with length 1.
  */
 @Operator
-public final class All extends PrimitiveOp implements Operand<TBool> {
+public final class All extends RawOp implements Operand<TBool> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.All}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Any.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Any.java
index 63203045d18..c30305b2207 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Any.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Any.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * retained with length 1.
  */
 @Operator
-public final class Any extends PrimitiveOp implements Operand<TBool> {
+public final class Any extends RawOp implements Operand<TBool> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Any}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssertThat.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssertThat.java
index 9d9ec8586d0..a56b01c90aa 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssertThat.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssertThat.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * `summarize` determines how many entries of the tensors to print.
  */
 @Operator
-public final class AssertThat extends PrimitiveOp {
+public final class AssertThat extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.AssertThat}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Assign.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Assign.java
index 2758130e272..c0319759f33 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Assign.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Assign.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class Assign<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Assign<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Assign}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignAdd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignAdd.java
index e6effd3189e..9208756aa95 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignAdd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignAdd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class AssignAdd<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class AssignAdd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.AssignAdd}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignAddVariableOp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignAddVariableOp.java
index 2585e2dfdc7..3725c318637 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignAddVariableOp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignAddVariableOp.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * see the incremented value or a subsequent newer one.
  */
 @Operator
-public final class AssignAddVariableOp extends PrimitiveOp {
+public final class AssignAddVariableOp extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new AssignAddVariableOp operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignSub.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignSub.java
index 095390bd8c7..13506b03543 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignSub.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignSub.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class AssignSub<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class AssignSub<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.AssignSub}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignSubVariableOp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignSubVariableOp.java
index 51ec2043d5a..c47fc330702 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignSubVariableOp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignSubVariableOp.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * see the decremented value or a subsequent newer one.
  */
 @Operator
-public final class AssignSubVariableOp extends PrimitiveOp {
+public final class AssignSubVariableOp extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new AssignSubVariableOp operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignVariableOp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignVariableOp.java
index 3ec75782de8..bdd89c0204d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignVariableOp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/AssignVariableOp.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * this value or a subsequent newer value of the variable.
  */
 @Operator
-public final class AssignVariableOp extends PrimitiveOp {
+public final class AssignVariableOp extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new AssignVariableOp operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Barrier.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Barrier.java
index 88fb6ce3eb6..4efa552a9b8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Barrier.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Barrier.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * and may be updated using BarrierInsertMany.
  */
 @Operator
-public final class Barrier extends PrimitiveOp implements Operand<TString> {
+public final class Barrier extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Barrier}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierClose.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierClose.java
index add20802efc..2b1cbc84c2b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierClose.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierClose.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * Subsequent TakeMany operations that would block will fail immediately.
  */
 @Operator
-public final class BarrierClose extends PrimitiveOp {
+public final class BarrierClose extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.BarrierClose}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierIncompleteSize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierIncompleteSize.java
index 9ae91f1c60a..62bcdcf1e56 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierIncompleteSize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierIncompleteSize.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * Computes the number of incomplete elements in the given barrier.
  */
 @Operator
-public final class BarrierIncompleteSize extends PrimitiveOp implements Operand<TInt32> {
+public final class BarrierIncompleteSize extends RawOp implements Operand<TInt32> {
   
   /**
    * Factory method to create a class wrapping a new BarrierIncompleteSize operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierInsertMany.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierInsertMany.java
index 3008cc9cc90..8e16fe1df11 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierInsertMany.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierInsertMany.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * INVALID_ARGUMENT, and leave the barrier in an undefined state.
  */
 @Operator
-public final class BarrierInsertMany extends PrimitiveOp {
+public final class BarrierInsertMany extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BarrierInsertMany operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierReadySize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierReadySize.java
index 274a4827a69..b3059b5b8c9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierReadySize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierReadySize.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * Computes the number of complete elements in the given barrier.
  */
 @Operator
-public final class BarrierReadySize extends PrimitiveOp implements Operand<TInt32> {
+public final class BarrierReadySize extends RawOp implements Operand<TInt32> {
   
   /**
    * Factory method to create a class wrapping a new BarrierReadySize operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierTakeMany.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierTakeMany.java
index be30e272126..481cdcd1d7a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierTakeMany.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BarrierTakeMany.java
@@ -24,7 +24,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * into the barrier.
  */
 @Operator
-public final class BarrierTakeMany extends PrimitiveOp {
+public final class BarrierTakeMany extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.BarrierTakeMany}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Batch.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Batch.java
index 1715a4cedee..895ad5e3c77 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Batch.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Batch.java
@@ -24,7 +24,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -71,7 +71,7 @@
  * T: the types of tensors to be batched.
  */
 @Operator
-public final class Batch extends PrimitiveOp {
+public final class Batch extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Batch}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BatchToSpace.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BatchToSpace.java
index a5d1fecd65a..3d1fc8af44e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BatchToSpace.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BatchToSpace.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class BatchToSpace<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class BatchToSpace<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchToSpace operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BatchToSpaceNd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BatchToSpaceNd.java
index e575b641ed3..8c2a3d9b703 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BatchToSpaceNd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BatchToSpaceNd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class BatchToSpaceNd<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class BatchToSpaceNd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchToSpaceNd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Bitcast.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Bitcast.java
index 6867c656710..fa7777e0d98 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Bitcast.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Bitcast.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -85,7 +85,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class Bitcast<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class Bitcast<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Bitcast operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BroadcastDynamicShape.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BroadcastDynamicShape.java
index 1fac6e571fc..88758189167 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BroadcastDynamicShape.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BroadcastDynamicShape.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code r0()} output
  */
 @Operator
-public final class BroadcastDynamicShape<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class BroadcastDynamicShape<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BroadcastDynamicShape operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BroadcastGradientArgs.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BroadcastGradientArgs.java
index d77f9f355f0..309cfef9430 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BroadcastGradientArgs.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BroadcastGradientArgs.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code r0()} output
  */
-public final class BroadcastGradientArgs<T extends TNumber> extends PrimitiveOp {
+public final class BroadcastGradientArgs<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BroadcastGradientArgs operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BroadcastTo.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BroadcastTo.java
index fb1d8999762..e4c1b80764f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BroadcastTo.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/BroadcastTo.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -53,7 +53,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class BroadcastTo<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class BroadcastTo<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BroadcastTo operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Bucketize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Bucketize.java
index cf43631adfd..f7f32115de1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Bucketize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Bucketize.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -45,7 +45,7 @@
  *               [1, 3]]
  */
 @Operator
-public final class Bucketize extends PrimitiveOp implements Operand<TInt32> {
+public final class Bucketize extends RawOp implements Operand<TInt32> {
   
   /**
    * Factory method to create a class wrapping a new Bucketize operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ClipByValue.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ClipByValue.java
index fa6d021ce3f..1c33f21ba98 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ClipByValue.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ClipByValue.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ClipByValue<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ClipByValue<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ClipByValue operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/CollectiveGather.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/CollectiveGather.java
index 15c6dd2e2ff..134570170f2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/CollectiveGather.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/CollectiveGather.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class CollectiveGather<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class CollectiveGather<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.CollectiveGather}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Concat.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Concat.java
index da0f8cada46..eb62cb86bf5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Concat.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Concat.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Concat<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Concat<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Concat operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ConsumeMutexLock.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ConsumeMutexLock.java
index f0e55b2792d..8a7440297f3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ConsumeMutexLock.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ConsumeMutexLock.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * be enforced via the `colocate_with` mechanism.
  */
 @Operator
-public final class ConsumeMutexLock extends PrimitiveOp {
+public final class ConsumeMutexLock extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ConsumeMutexLock operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ControlTrigger.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ControlTrigger.java
index d4a890a88cb..9c1baf17ed3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ControlTrigger.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ControlTrigger.java
@@ -19,7 +19,7 @@
 
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
  * Only useful as a placeholder for control edges.
  */
 @Operator
-public final class ControlTrigger extends PrimitiveOp {
+public final class ControlTrigger extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ControlTrigger operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Copy.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Copy.java
index 7d3e07381f5..6ca879bf1b9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Copy.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Copy.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class Copy<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Copy<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Copy}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/CopyHost.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/CopyHost.java
index 38c8d5da9e9..b57961ead25 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/CopyHost.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/CopyHost.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class CopyHost<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class CopyHost<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.CopyHost}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/CountUpTo.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/CountUpTo.java
index be27d0c5e72..84dfbc90633 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/CountUpTo.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/CountUpTo.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class CountUpTo<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class CountUpTo<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new CountUpTo operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugGradientIdentity.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugGradientIdentity.java
index 60cc5bbc5b9..b8626aa0527 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugGradientIdentity.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugGradientIdentity.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class DebugGradientIdentity<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class DebugGradientIdentity<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DebugGradientIdentity operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugGradientRefIdentity.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugGradientRefIdentity.java
index b4ed8481c91..ede36ae9554 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugGradientRefIdentity.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugGradientRefIdentity.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class DebugGradientRefIdentity<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class DebugGradientRefIdentity<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DebugGradientRefIdentity operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugIdentity.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugIdentity.java
index 061e985062c..370c556462b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugIdentity.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugIdentity.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class DebugIdentity<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class DebugIdentity<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.DebugIdentity}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugIdentityV2.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugIdentityV2.java
index fd83aa5bb81..50c96d03efd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugIdentityV2.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugIdentityV2.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class DebugIdentityV2<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class DebugIdentityV2<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.DebugIdentityV2}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugNanCount.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugNanCount.java
index 73d8fd36950..9ce13c0084a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugNanCount.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugNanCount.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * <p>
  * Counts number of NaNs in the input tensor, for debugging.
  */
-public final class DebugNanCount extends PrimitiveOp implements Operand<TInt64> {
+public final class DebugNanCount extends RawOp implements Operand<TInt64> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.DebugNanCount}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugNumericSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugNumericSummary.java
index 8b3a627ebec..4c10d3b3dcb 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugNumericSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugNumericSummary.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -63,7 +63,7 @@
  *   [14+]: Sizes of the dimensions.
  * 
  */
-public final class DebugNumericSummary extends PrimitiveOp implements Operand<TFloat64> {
+public final class DebugNumericSummary extends RawOp implements Operand<TFloat64> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.DebugNumericSummary}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugNumericSummaryV2.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugNumericSummaryV2.java
index b95125c0995..423f8dacb2f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugNumericSummaryV2.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DebugNumericSummaryV2.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * depends on the tensor_debug_mode attribute.
  * This op is used internally by TensorFlow Debugger (tfdbg) v2.
  */
-public final class DebugNumericSummaryV2 extends PrimitiveOp implements Operand<TFloat32> {
+public final class DebugNumericSummaryV2 extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.DebugNumericSummaryV2}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DecodeProto.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DecodeProto.java
index c67ca8ee2a4..8a423575c08 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DecodeProto.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DecodeProto.java
@@ -24,7 +24,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -82,7 +82,7 @@
  * - A "bytes://<bytes>", in which protocol descriptors are created from `<bytes>`,
  * which is expected to be a `FileDescriptorSet` serialized as a string.
  */
-public final class DecodeProto extends PrimitiveOp {
+public final class DecodeProto extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.DecodeProto}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DeepCopy.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DeepCopy.java
index 1e13fdf895c..0abe365a8a9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DeepCopy.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DeepCopy.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class DeepCopy<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class DeepCopy<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DeepCopy operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DeleteSessionTensor.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DeleteSessionTensor.java
index bd478010aa4..2da72b19db9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DeleteSessionTensor.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DeleteSessionTensor.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
  * Delete the tensor specified by its handle in the session.
  */
 @Operator
-public final class DeleteSessionTensor extends PrimitiveOp {
+public final class DeleteSessionTensor extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new DeleteSessionTensor operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DestroyResourceOp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DestroyResourceOp.java
index 363eb11cde5..dc494cea751 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DestroyResourceOp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DestroyResourceOp.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * error status.
  */
 @Operator
-public final class DestroyResourceOp extends PrimitiveOp {
+public final class DestroyResourceOp extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.DestroyResourceOp}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DestroyTemporaryVariable.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DestroyTemporaryVariable.java
index 5331332f111..65fa9c62e4a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DestroyTemporaryVariable.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DestroyTemporaryVariable.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class DestroyTemporaryVariable<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class DestroyTemporaryVariable<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DestroyTemporaryVariable operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DynamicPartition.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DynamicPartition.java
index 0fc19695e64..48dd3b54f8e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DynamicPartition.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DynamicPartition.java
@@ -24,7 +24,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -71,7 +71,7 @@
  * @param <T> data type for {@code outputs()} output
  */
 @Operator
-public final class DynamicPartition<T extends TType> extends PrimitiveOp implements Iterable<Operand<T>> {
+public final class DynamicPartition<T extends TType> extends RawOp implements Iterable<Operand<T>> {
   
   /**
    * Factory method to create a class wrapping a new DynamicPartition operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DynamicStitch.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DynamicStitch.java
index f0fcf6f69b7..ba41dcf77f8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DynamicStitch.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DynamicStitch.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -90,7 +90,7 @@
  * @param <T> data type for {@code merged()} output
  */
 @Operator
-public final class DynamicStitch<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class DynamicStitch<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DynamicStitch operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/EditDistance.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/EditDistance.java
index e6ac7c73326..7c0a35798d5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/EditDistance.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/EditDistance.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * The inputs are:
  */
 @Operator
-public final class EditDistance extends PrimitiveOp implements Operand<TFloat32> {
+public final class EditDistance extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.EditDistance}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Empty.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Empty.java
index 6f4ead28227..0e39ea25f92 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Empty.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Empty.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Empty<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Empty<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Empty}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/EmptyTensorList.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/EmptyTensorList.java
index f4af0029295..e91ebafbb03 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/EmptyTensorList.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/EmptyTensorList.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * element_shape: a shape compatible with that of elements in the list.
  */
 @Operator
-public final class EmptyTensorList extends PrimitiveOp implements Operand<TType> {
+public final class EmptyTensorList extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new EmptyTensorList operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/EncodeProto.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/EncodeProto.java
index bc50f057502..6f2e448d053 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/EncodeProto.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/EncodeProto.java
@@ -23,7 +23,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -74,7 +74,7 @@
  * - A "bytes://<bytes>", in which protocol descriptors are created from `<bytes>`,
  * which is expected to be a `FileDescriptorSet` serialized as a string.
  */
-public final class EncodeProto extends PrimitiveOp implements Operand<TString> {
+public final class EncodeProto extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.EncodeProto}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/EnsureShape.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/EnsureShape.java
index 0c6467ec7ef..13f8072bcf1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/EnsureShape.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/EnsureShape.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class EnsureShape<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class EnsureShape<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new EnsureShape operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Enter.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Enter.java
index 6b3b2076c46..d6802061959 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Enter.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Enter.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class Enter<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Enter<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Enter}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Exit.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Exit.java
index 2558de68d5f..879225e5dbc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Exit.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Exit.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class Exit<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Exit<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Exit operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ExpandDims.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ExpandDims.java
index afb64d4c61e..12cb36b98dc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ExpandDims.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ExpandDims.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -63,7 +63,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ExpandDims<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ExpandDims<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ExpandDims operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ExtractVolumePatches.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ExtractVolumePatches.java
index aee02ea1da8..6816275860b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ExtractVolumePatches.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ExtractVolumePatches.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code patches()} output
  */
 @Operator
-public final class ExtractVolumePatches<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class ExtractVolumePatches<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ExtractVolumePatches operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Fill.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Fill.java
index 980408cd341..adbcc23f363 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Fill.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Fill.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -57,7 +57,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class Fill<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class Fill<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Fill operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Fingerprint.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Fingerprint.java
index 965cafea033..4aca6b0201e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Fingerprint.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Fingerprint.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -62,7 +62,7 @@
  * Fingerprint(ReduceJoin(data))` in general.
  */
 @Operator
-public final class Fingerprint extends PrimitiveOp implements Operand<TUint8> {
+public final class Fingerprint extends RawOp implements Operand<TUint8> {
   
   /**
    * Factory method to create a class wrapping a new Fingerprint operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Gather.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Gather.java
index ce65f32389c..8eaec57f813 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Gather.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Gather.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -60,7 +60,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Gather<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Gather<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Gather}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/GatherNd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/GatherNd.java
index 3782a75d4c4..917db87705f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/GatherNd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/GatherNd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -127,7 +127,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class GatherNd<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class GatherNd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new GatherNd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/GetSessionHandle.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/GetSessionHandle.java
index 5fcdfbdf47a..57754705177 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/GetSessionHandle.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/GetSessionHandle.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Store the input tensor in the state of the current session.
  */
 @Operator
-public final class GetSessionHandle extends PrimitiveOp implements Operand<TType> {
+public final class GetSessionHandle extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new GetSessionHandle operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/GetSessionTensor.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/GetSessionTensor.java
index ab41ba6e355..634b23ed56c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/GetSessionTensor.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/GetSessionTensor.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class GetSessionTensor<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class GetSessionTensor<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new GetSessionTensor operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/GuaranteeConst.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/GuaranteeConst.java
index eacaaac6a35..ff9064f3ac9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/GuaranteeConst.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/GuaranteeConst.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class GuaranteeConst<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class GuaranteeConst<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new GuaranteeConst operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/HashTable.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/HashTable.java
index 8b22d00b9ab..2b097647e32 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/HashTable.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/HashTable.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * table will be immutable.
  */
 @Operator
-public final class HashTable extends PrimitiveOp implements Operand<TType> {
+public final class HashTable extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.HashTable}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/HistogramFixedWidth.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/HistogramFixedWidth.java
index cf48e5ad5c2..b7f7a90a90d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/HistogramFixedWidth.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/HistogramFixedWidth.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -52,7 +52,7 @@
  * @param <U> data type for {@code out()} output
  */
 @Operator
-public final class HistogramFixedWidth<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class HistogramFixedWidth<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new HistogramFixedWidth operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Identity.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Identity.java
index 253ce7a016b..32c3d0d4cab 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Identity.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Identity.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Identity<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Identity<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Identity operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/IdentityN.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/IdentityN.java
index 38c70bd4f70..4ad5ab1f261 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/IdentityN.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/IdentityN.java
@@ -25,7 +25,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -51,7 +51,7 @@
  * 
  */
 @Operator
-public final class IdentityN extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class IdentityN extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new IdentityN operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ImmutableConst.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ImmutableConst.java
index 618ded962f8..0327093fc4d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ImmutableConst.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ImmutableConst.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code tensor()} output
  */
 @Operator
-public final class ImmutableConst<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ImmutableConst<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ImmutableConst operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InitializeTable.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InitializeTable.java
index f7215866d2e..2ffb3c37290 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InitializeTable.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InitializeTable.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
  * Table initializer that takes two tensors for keys and values respectively.
  */
 @Operator
-public final class InitializeTable extends PrimitiveOp {
+public final class InitializeTable extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new InitializeTable operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InitializeTableFromTextFile.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InitializeTableFromTextFile.java
index c2fd3f0c775..672bf052e49 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InitializeTableFromTextFile.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InitializeTableFromTextFile.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  *   on `delimiter`.
  */
 @Operator
-public final class InitializeTableFromTextFile extends PrimitiveOp {
+public final class InitializeTableFromTextFile extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.InitializeTableFromTextFile}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InplaceAdd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InplaceAdd.java
index 3af3e91cfde..5eab2e36d95 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InplaceAdd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InplaceAdd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class InplaceAdd<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class InplaceAdd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new InplaceAdd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InplaceSub.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InplaceSub.java
index 38580610d13..7ff3c5ef9bc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InplaceSub.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InplaceSub.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class InplaceSub<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class InplaceSub<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new InplaceSub operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InplaceUpdate.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InplaceUpdate.java
index b20ad099152..877c9400f7f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InplaceUpdate.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/InplaceUpdate.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class InplaceUpdate<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class InplaceUpdate<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new InplaceUpdate operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/IsVariableInitialized.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/IsVariableInitialized.java
index f881703ac03..f4f6bf5fe36 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/IsVariableInitialized.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/IsVariableInitialized.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * Outputs boolean scalar indicating whether the tensor has been initialized.
  */
 @Operator
-public final class IsVariableInitialized extends PrimitiveOp implements Operand<TBool> {
+public final class IsVariableInitialized extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new IsVariableInitialized operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LinSpace.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LinSpace.java
index f84331c3716..c8b4d2dfa95 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LinSpace.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LinSpace.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class LinSpace<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class LinSpace<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new LinSpace operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableExport.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableExport.java
index 8b437164fd9..0f31790fe45 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableExport.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableExport.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <U> data type for {@code values()} output
  */
 @Operator
-public final class LookupTableExport<T extends TType, U extends TType> extends PrimitiveOp {
+public final class LookupTableExport<T extends TType, U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new LookupTableExport operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableFind.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableFind.java
index 49d0d9820cf..e0dbead12d2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableFind.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableFind.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <U> data type for {@code values()} output
  */
 @Operator
-public final class LookupTableFind<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class LookupTableFind<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new LookupTableFind operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableImport.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableImport.java
index 609a2d695cb..3df4d4653e0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableImport.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableImport.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * The tensor `values` must be of the type of the table values.
  */
 @Operator
-public final class LookupTableImport extends PrimitiveOp {
+public final class LookupTableImport extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new LookupTableImport operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableInsert.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableInsert.java
index 78fde820838..9e355312479 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableInsert.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableInsert.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * The tensor `values` must be of the type of the table values.
  */
 @Operator
-public final class LookupTableInsert extends PrimitiveOp {
+public final class LookupTableInsert extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new LookupTableInsert operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableRemove.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableRemove.java
index 0be66badffc..875bbfa486c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableRemove.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableRemove.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * The tensor `keys` must of the same type as the keys of the table. Keys not
  * already in the table are silently ignored.
  */
-public final class LookupTableRemove extends PrimitiveOp {
+public final class LookupTableRemove extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new LookupTableRemove operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableSize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableSize.java
index 520e05c3fdd..441c2208bd3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableSize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LookupTableSize.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Computes the number of elements in the given table.
  */
 @Operator
-public final class LookupTableSize extends PrimitiveOp implements Operand<TInt64> {
+public final class LookupTableSize extends RawOp implements Operand<TInt64> {
   
   /**
    * Factory method to create a class wrapping a new LookupTableSize operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LoopCond.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LoopCond.java
index 9a161a7bb36..bef80f40840 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LoopCond.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LoopCond.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * "pivot" switches of a loop.
  */
 @Operator
-public final class LoopCond extends PrimitiveOp implements Operand<TBool> {
+public final class LoopCond extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new LoopCond operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LowerBound.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LowerBound.java
index 7390d1d1f2c..db36ee86241 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LowerBound.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/LowerBound.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -53,7 +53,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class LowerBound<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class LowerBound<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new LowerBound operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapClear.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapClear.java
index 92630709b20..5ffc0da9c6c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapClear.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapClear.java
@@ -21,7 +21,7 @@
 import org.tensorflow.DataType;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
  * Op removes all elements in the underlying container.
  */
 @Operator
-public final class MapClear extends PrimitiveOp {
+public final class MapClear extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MapClear}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapIncompleteSize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapIncompleteSize.java
index 916c6c114be..a4522bb2993 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapIncompleteSize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapIncompleteSize.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * Op returns the number of incomplete elements in the underlying container.
  */
 @Operator
-public final class MapIncompleteSize extends PrimitiveOp implements Operand<TInt32> {
+public final class MapIncompleteSize extends RawOp implements Operand<TInt32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MapIncompleteSize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapPeek.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapPeek.java
index 8f0db411260..38087a7b46f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapPeek.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapPeek.java
@@ -25,7 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * this op will block until it does.
  */
 @Operator
-public final class MapPeek extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class MapPeek extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MapPeek}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapSize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapSize.java
index b9a0aac2f21..20a2b619d1e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapSize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapSize.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * Op returns the number of elements in the underlying container.
  */
 @Operator
-public final class MapSize extends PrimitiveOp implements Operand<TInt32> {
+public final class MapSize extends RawOp implements Operand<TInt32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MapSize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapStage.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapStage.java
index c884b33426f..cc09bdf78a2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapStage.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapStage.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * Stage (key, values) in the underlying container which behaves like a hashtable.
  */
 @Operator
-public final class MapStage extends PrimitiveOp {
+public final class MapStage extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MapStage}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapUnstage.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapUnstage.java
index ab280bafcc6..932c1f4f970 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapUnstage.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapUnstage.java
@@ -25,7 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * does not contain this key, the op will block until it does.
  */
 @Operator
-public final class MapUnstage extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class MapUnstage extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MapUnstage}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapUnstageNoKey.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapUnstageNoKey.java
index f5898841278..a915362108e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapUnstageNoKey.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MapUnstageNoKey.java
@@ -24,7 +24,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * does not contain elements, the op will block until it does.
  */
 @Operator
-public final class MapUnstageNoKey extends PrimitiveOp {
+public final class MapUnstageNoKey extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MapUnstageNoKey}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Max.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Max.java
index c6ddc3c40cd..e97fc9d17ca 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Max.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Max.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Max<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Max<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Max}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Merge.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Merge.java
index fe498e933e9..476253b5601 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Merge.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Merge.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Merge<T extends TType> extends PrimitiveOp {
+public final class Merge<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new Merge operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Min.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Min.java
index 2befc2d0207..c19b8eaefdf 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Min.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Min.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Min<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Min<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Min}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MirrorPad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MirrorPad.java
index fb16d956272..beb9448138c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MirrorPad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MirrorPad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -60,7 +60,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class MirrorPad<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class MirrorPad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new MirrorPad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MirrorPadGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MirrorPadGrad.java
index be8dce8c598..ee3a76eab9f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MirrorPadGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MirrorPadGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -52,7 +52,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class MirrorPadGrad<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class MirrorPadGrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new MirrorPadGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MlirPassthroughOp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MlirPassthroughOp.java
index bb6bc473c51..fc482784607 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MlirPassthroughOp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MlirPassthroughOp.java
@@ -26,7 +26,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -66,7 +66,7 @@
  * 
  */
 @Operator
-public final class MlirPassthroughOp extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class MlirPassthroughOp extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new MlirPassthroughOp operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MutableDenseHashTable.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MutableDenseHashTable.java
index 7340e3cdc12..d98496ac4d3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MutableDenseHashTable.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MutableDenseHashTable.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * the insert operations. It does not support the initialization operation.
  */
 @Operator
-public final class MutableDenseHashTable extends PrimitiveOp implements Operand<TType> {
+public final class MutableDenseHashTable extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MutableDenseHashTable}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MutableHashTable.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MutableHashTable.java
index 3cc34d48711..74d304d82ab 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MutableHashTable.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MutableHashTable.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * the insert operations. It does not support the initialization operation.
  */
 @Operator
-public final class MutableHashTable extends PrimitiveOp implements Operand<TType> {
+public final class MutableHashTable extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MutableHashTable}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MutableHashTableOfTensors.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MutableHashTableOfTensors.java
index 465481fe18d..d2d7354422f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MutableHashTableOfTensors.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MutableHashTableOfTensors.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * the insert operations. It does not support the initialization operation.
  */
 @Operator
-public final class MutableHashTableOfTensors extends PrimitiveOp implements Operand<TType> {
+public final class MutableHashTableOfTensors extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MutableHashTableOfTensors}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Mutex.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Mutex.java
index 0c8bc700e06..41f57d9a755 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Mutex.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Mutex.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Creates a Mutex resource that can be locked by `MutexLock`.
  */
 @Operator
-public final class Mutex extends PrimitiveOp implements Operand<TType> {
+public final class Mutex extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Mutex}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MutexLock.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MutexLock.java
index cb7eff8bc57..e67ea7a228b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MutexLock.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/MutexLock.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -67,7 +67,7 @@
  * wish to ensure the usage is exclusive.
  */
 @Operator
-public final class MutexLock extends PrimitiveOp implements Operand<TType> {
+public final class MutexLock extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new MutexLock operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NcclAllReduce.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NcclAllReduce.java
index f0c8ff203cc..179e8f08e1d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NcclAllReduce.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NcclAllReduce.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -46,7 +46,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class NcclAllReduce<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class NcclAllReduce<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new NcclAllReduce operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NcclBroadcast.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NcclBroadcast.java
index 09e16907b59..84767e7f21c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NcclBroadcast.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NcclBroadcast.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class NcclBroadcast<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class NcclBroadcast<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new NcclBroadcast operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NcclReduce.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NcclReduce.java
index efff746d266..c6376f1a908 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NcclReduce.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NcclReduce.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class NcclReduce<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class NcclReduce<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new NcclReduce operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NextIteration.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NextIteration.java
index 6a8f17e0773..99f0fa0dd1b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NextIteration.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NextIteration.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class NextIteration<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class NextIteration<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new NextIteration operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NoOp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NoOp.java
index 40fe567832a..aa37e24c61a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NoOp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/NoOp.java
@@ -19,7 +19,7 @@
 
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -28,7 +28,7 @@
  * Does nothing. Only useful as a placeholder for control edges.
  */
 @Operator
-public final class NoOp extends PrimitiveOp {
+public final class NoOp extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new NoOp operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OneHot.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OneHot.java
index 423fc169ef3..9b4d6a4927d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OneHot.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OneHot.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -116,7 +116,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class OneHot<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class OneHot<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.OneHot}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OnesLike.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OnesLike.java
index f48706ad9f5..5d9ce5861c2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OnesLike.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OnesLike.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class OnesLike<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class OnesLike<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new OnesLike operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapClear.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapClear.java
index 918a1940bac..df85e76bc3b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapClear.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapClear.java
@@ -21,7 +21,7 @@
 import org.tensorflow.DataType;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
  * Op removes all elements in the underlying container.
  */
 @Operator
-public final class OrderedMapClear extends PrimitiveOp {
+public final class OrderedMapClear extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.OrderedMapClear}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapIncompleteSize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapIncompleteSize.java
index 0ef70bc3800..9ae3fd09642 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapIncompleteSize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapIncompleteSize.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * Op returns the number of incomplete elements in the underlying container.
  */
 @Operator
-public final class OrderedMapIncompleteSize extends PrimitiveOp implements Operand<TInt32> {
+public final class OrderedMapIncompleteSize extends RawOp implements Operand<TInt32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.OrderedMapIncompleteSize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapPeek.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapPeek.java
index a62c2c1f5e9..dd7fc0e3f40 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapPeek.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapPeek.java
@@ -25,7 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * performance.
  */
 @Operator
-public final class OrderedMapPeek extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class OrderedMapPeek extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.OrderedMapPeek}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapSize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapSize.java
index f769fd9e0fd..d16383393f4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapSize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapSize.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * Op returns the number of elements in the underlying container.
  */
 @Operator
-public final class OrderedMapSize extends PrimitiveOp implements Operand<TInt32> {
+public final class OrderedMapSize extends RawOp implements Operand<TInt32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.OrderedMapSize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapStage.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapStage.java
index c6cb7351021..c752a0dd84e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapStage.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapStage.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * associative container.   Elements are ordered by key.
  */
 @Operator
-public final class OrderedMapStage extends PrimitiveOp {
+public final class OrderedMapStage extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.OrderedMapStage}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapUnstage.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapUnstage.java
index 92b7365c9ef..c44e344638d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapUnstage.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapUnstage.java
@@ -25,7 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * does not contain this key, the op will block until it does.
  */
 @Operator
-public final class OrderedMapUnstage extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class OrderedMapUnstage extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.OrderedMapUnstage}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapUnstageNoKey.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapUnstageNoKey.java
index 1ccc2861eca..d0fa6beea68 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapUnstageNoKey.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/OrderedMapUnstageNoKey.java
@@ -24,7 +24,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * does not contain elements, the op will block until it does.
  */
 @Operator
-public final class OrderedMapUnstageNoKey extends PrimitiveOp {
+public final class OrderedMapUnstageNoKey extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.OrderedMapUnstageNoKey}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Pad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Pad.java
index 90d0d0429b4..c21f7aa9a58 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Pad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Pad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -59,7 +59,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Pad<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Pad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Pad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ParallelConcat.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ParallelConcat.java
index 51e717d3147..4c7a5cec64a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ParallelConcat.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ParallelConcat.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -50,7 +50,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ParallelConcat<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ParallelConcat<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ParallelConcat operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ParallelDynamicStitch.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ParallelDynamicStitch.java
index bff37ed1abe..3fd6514f285 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ParallelDynamicStitch.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ParallelDynamicStitch.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -89,7 +89,7 @@
  * @param <T> data type for {@code merged()} output
  */
 @Operator
-public final class ParallelDynamicStitch<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ParallelDynamicStitch<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ParallelDynamicStitch operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Placeholder.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Placeholder.java
index 5a068a4621e..2da694bedc9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Placeholder.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Placeholder.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Placeholder<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Placeholder<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Placeholder}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/PlaceholderWithDefault.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/PlaceholderWithDefault.java
index 3142c81d456..599e1e17070 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/PlaceholderWithDefault.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/PlaceholderWithDefault.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class PlaceholderWithDefault<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class PlaceholderWithDefault<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new PlaceholderWithDefault operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Print.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Print.java
index d1ffccdefd3..1f341e11de5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Print.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Print.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * Prints a string scalar to the desired output_stream.
  */
 @Operator
-public final class Print extends PrimitiveOp {
+public final class Print extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Print}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Prod.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Prod.java
index a9fccd49163..b9b7b8b65a4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Prod.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Prod.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Prod<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Prod<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Prod}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/QuantizedReshape.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/QuantizedReshape.java
index 23035b712d3..f4996cd8875 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/QuantizedReshape.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/QuantizedReshape.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class QuantizedReshape<T extends TType> extends PrimitiveOp {
+public final class QuantizedReshape<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedReshape operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Range.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Range.java
index be84fc3e34c..5134f49c314 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Range.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Range.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -46,7 +46,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Range<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Range<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Range operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Rank.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Rank.java
index 6949f8b7067..f7e1959280d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Rank.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Rank.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * of the tensor. Rank is also known as "order", "degree", or "ndims."
  */
 @Operator
-public final class Rank extends PrimitiveOp implements Operand<TInt32> {
+public final class Rank extends RawOp implements Operand<TInt32> {
   
   /**
    * Factory method to create a class wrapping a new Rank operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReadVariableOp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReadVariableOp.java
index 7507661cfe7..c535547a925 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReadVariableOp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReadVariableOp.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class ReadVariableOp<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ReadVariableOp<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ReadVariableOp operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Recv.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Recv.java
index a51a103a340..5feb610b6fd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Recv.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Recv.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * 
  * @param <T> data type for {@code tensor()} output
  */
-public final class Recv<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Recv<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Recv}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceAll.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceAll.java
index ca1719b34da..195a7bbbce8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceAll.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceAll.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * retained with length 1.
  */
 @Operator
-public final class ReduceAll extends PrimitiveOp implements Operand<TBool> {
+public final class ReduceAll extends RawOp implements Operand<TBool> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ReduceAll}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceAny.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceAny.java
index 87214d75fb8..9dde0ff6238 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceAny.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceAny.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * retained with length 1.
  */
 @Operator
-public final class ReduceAny extends PrimitiveOp implements Operand<TBool> {
+public final class ReduceAny extends RawOp implements Operand<TBool> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ReduceAny}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceMax.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceMax.java
index 622ad4a6713..1df06cb441d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceMax.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceMax.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ReduceMax<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ReduceMax<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ReduceMax}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceMin.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceMin.java
index d4c05d8fd47..2ebdaa01247 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceMin.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceMin.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ReduceMin<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ReduceMin<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ReduceMin}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceProd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceProd.java
index 050781dddd7..37fcf044469 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceProd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceProd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ReduceProd<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ReduceProd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ReduceProd}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceSum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceSum.java
index 2fa8ea87d28..82bf9d35558 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceSum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReduceSum.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ReduceSum<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ReduceSum<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ReduceSum}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefEnter.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefEnter.java
index c3d10630112..bec8abb5f80 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefEnter.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefEnter.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class RefEnter<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class RefEnter<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.RefEnter}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefExit.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefExit.java
index 8a606f16509..80399854da4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefExit.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefExit.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class RefExit<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class RefExit<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RefExit operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefIdentity.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefIdentity.java
index 3ce75aa6dc5..e3840bfa886 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefIdentity.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefIdentity.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class RefIdentity<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class RefIdentity<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RefIdentity operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefMerge.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefMerge.java
index ddb399d3f2f..eab96521ea6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefMerge.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefMerge.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class RefMerge<T extends TType> extends PrimitiveOp {
+public final class RefMerge<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RefMerge operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefNextIteration.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefNextIteration.java
index 9399d6ce0e4..bb1423440fd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefNextIteration.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefNextIteration.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class RefNextIteration<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class RefNextIteration<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RefNextIteration operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefSelect.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefSelect.java
index a3141597cf6..23864ed4820 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefSelect.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefSelect.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class RefSelect<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class RefSelect<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RefSelect operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefSwitch.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefSwitch.java
index 426c25fb076..b45250bb083 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefSwitch.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RefSwitch.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code outputFalse()} output
  */
 @Operator
-public final class RefSwitch<T extends TType> extends PrimitiveOp {
+public final class RefSwitch<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RefSwitch operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RemoteFusedGraphExecute.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RemoteFusedGraphExecute.java
index c99c4ef954e..0242749bda6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RemoteFusedGraphExecute.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/RemoteFusedGraphExecute.java
@@ -26,7 +26,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * will be passed to consumer nodes as outputs of this node.
  */
 @Operator
-public final class RemoteFusedGraphExecute extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class RemoteFusedGraphExecute extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new RemoteFusedGraphExecute operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Reshape.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Reshape.java
index 31587111b51..eaeaa5ded4e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Reshape.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Reshape.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -94,7 +94,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Reshape<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Reshape<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Reshape operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceCountUpTo.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceCountUpTo.java
index 0321f27a255..cce86ab05ce 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceCountUpTo.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceCountUpTo.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ResourceCountUpTo<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class ResourceCountUpTo<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ResourceCountUpTo operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceGather.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceGather.java
index 688bd48c218..fd8ccc35cfa 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceGather.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceGather.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -49,7 +49,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class ResourceGather<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class ResourceGather<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ResourceGather}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceGatherNd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceGatherNd.java
index 45869b9752d..f2c501ec524 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceGatherNd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceGatherNd.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class ResourceGatherNd<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class ResourceGatherNd<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new ResourceGatherNd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterAdd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterAdd.java
index 128bb43e3cb..630a3716695 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterAdd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterAdd.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -51,7 +51,7 @@
  * </div>
  */
 @Operator
-public final class ResourceScatterAdd extends PrimitiveOp {
+public final class ResourceScatterAdd extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ResourceScatterAdd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterDiv.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterDiv.java
index 792d534be76..dba2e37ec12 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterDiv.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterDiv.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -51,7 +51,7 @@
  * </div>
  */
 @Operator
-public final class ResourceScatterDiv extends PrimitiveOp {
+public final class ResourceScatterDiv extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ResourceScatterDiv operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterMax.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterMax.java
index 55bbe542324..6068660a905 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterMax.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterMax.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -51,7 +51,7 @@
  * </div>
  */
 @Operator
-public final class ResourceScatterMax extends PrimitiveOp {
+public final class ResourceScatterMax extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ResourceScatterMax operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterMin.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterMin.java
index 1349b78c923..3e0ffeae23a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterMin.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterMin.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -51,7 +51,7 @@
  * </div>
  */
 @Operator
-public final class ResourceScatterMin extends PrimitiveOp {
+public final class ResourceScatterMin extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ResourceScatterMin operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterMul.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterMul.java
index 56652d2c166..1a8feb21838 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterMul.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterMul.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -51,7 +51,7 @@
  * </div>
  */
 @Operator
-public final class ResourceScatterMul extends PrimitiveOp {
+public final class ResourceScatterMul extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ResourceScatterMul operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterNdAdd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterNdAdd.java
index 6ef119a5cfa..a230b7d58bf 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterNdAdd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterNdAdd.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -61,7 +61,7 @@
  * slices.
  */
 @Operator
-public final class ResourceScatterNdAdd extends PrimitiveOp {
+public final class ResourceScatterNdAdd extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ResourceScatterNdAdd}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterNdSub.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterNdSub.java
index cbee38f1dc2..9912c63f129 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterNdSub.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterNdSub.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -61,7 +61,7 @@
  * slices.
  */
 @Operator
-public final class ResourceScatterNdSub extends PrimitiveOp {
+public final class ResourceScatterNdSub extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ResourceScatterNdSub}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterNdUpdate.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterNdUpdate.java
index 9d07f53cfb6..625010c6aac 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterNdUpdate.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterNdUpdate.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -63,7 +63,7 @@
  * slices.
  */
 @Operator
-public final class ResourceScatterNdUpdate extends PrimitiveOp {
+public final class ResourceScatterNdUpdate extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ResourceScatterNdUpdate}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterSub.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterSub.java
index 27af1bc0262..727dc01ab32 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterSub.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterSub.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -51,7 +51,7 @@
  * </div>
  */
 @Operator
-public final class ResourceScatterSub extends PrimitiveOp {
+public final class ResourceScatterSub extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ResourceScatterSub operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterUpdate.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterUpdate.java
index 63f5f753e62..c75107a4bb7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterUpdate.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceScatterUpdate.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  *     ref[indices[i, ..., j], ...] = updates[i, ..., j, ...]
  */
 @Operator
-public final class ResourceScatterUpdate extends PrimitiveOp {
+public final class ResourceScatterUpdate extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ResourceScatterUpdate operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceStridedSliceAssign.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceStridedSliceAssign.java
index 29b61ab39f8..10c93185348 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceStridedSliceAssign.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ResourceStridedSliceAssign.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * shape must be exactly the shape produced by the slice of `ref`.
  */
 @Operator
-public final class ResourceStridedSliceAssign extends PrimitiveOp {
+public final class ResourceStridedSliceAssign extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ResourceStridedSliceAssign}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Reverse.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Reverse.java
index 1b823c9044e..e64e165182f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Reverse.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Reverse.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -81,7 +81,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Reverse<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Reverse<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Reverse operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReverseSequence.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReverseSequence.java
index 1bdcdfc02b1..a78de7f9a4c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReverseSequence.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ReverseSequence.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -87,7 +87,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ReverseSequence<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ReverseSequence<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ReverseSequence}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Roll.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Roll.java
index 6fbe9782fdd..8f6559ca09f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Roll.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Roll.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -55,7 +55,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Roll<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Roll<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Roll operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Rpc.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Rpc.java
index fab11c18245..2d753afec51 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Rpc.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Rpc.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -75,7 +75,7 @@
  * See the `TryRpc` op if you prefer to handle RPC failures manually in the graph.
  */
 @Operator
-public final class Rpc extends PrimitiveOp implements Operand<TString> {
+public final class Rpc extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Rpc}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterAdd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterAdd.java
index 2869638f5b4..5d18510e225 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterAdd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterAdd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterAdd<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ScatterAdd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterAdd}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterDiv.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterDiv.java
index acaf1bf8e3c..800dada981d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterDiv.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterDiv.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -53,7 +53,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterDiv<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ScatterDiv<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterDiv}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterMax.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterMax.java
index 1f64462dcf5..99e97ee0d23 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterMax.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterMax.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterMax<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class ScatterMax<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterMax}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterMin.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterMin.java
index dbe22dd0dd5..3b96560077a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterMin.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterMin.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterMin<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class ScatterMin<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterMin}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterMul.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterMul.java
index 6eef5484288..38305790fb5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterMul.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterMul.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -53,7 +53,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterMul<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ScatterMul<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterMul}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNd.java
index 9b92637e9b4..c59c526ca86 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -111,7 +111,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class ScatterNd<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class ScatterNd<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new ScatterNd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNdAdd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNdAdd.java
index 28fb25f6ef8..11b1ddc0ef8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNdAdd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNdAdd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -64,7 +64,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterNdAdd<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ScatterNdAdd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterNdAdd}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNdNonAliasingAdd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNdNonAliasingAdd.java
index b7bbbdc7fb8..400f7e8b11c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNdNonAliasingAdd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNdNonAliasingAdd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -68,7 +68,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ScatterNdNonAliasingAdd<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ScatterNdNonAliasingAdd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ScatterNdNonAliasingAdd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNdSub.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNdSub.java
index acf0938dde2..bbeafdaa08b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNdSub.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNdSub.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -66,7 +66,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterNdSub<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ScatterNdSub<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterNdSub}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNdUpdate.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNdUpdate.java
index 96da9b674a2..c715f6c1c92 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNdUpdate.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterNdUpdate.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -68,7 +68,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterNdUpdate<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ScatterNdUpdate<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterNdUpdate}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterSub.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterSub.java
index f9559455965..5bdb1e39081 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterSub.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterSub.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -56,7 +56,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterSub<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ScatterSub<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterSub}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterUpdate.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterUpdate.java
index 96f2f5aa7ba..fc548962aa7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterUpdate.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ScatterUpdate.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -60,7 +60,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterUpdate<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ScatterUpdate<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterUpdate}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Select.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Select.java
index 2d6151c8f07..fff55e1cf71 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Select.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Select.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Select<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Select<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Select operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Send.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Send.java
index e0ccce89f22..04f1f5813b3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Send.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Send.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
 /**
  * Sends the named tensor from send_device to recv_device.
  */
-public final class Send extends PrimitiveOp {
+public final class Send extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Send}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SetDiff1d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SetDiff1d.java
index 5e86c54fec2..1b13994eebc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SetDiff1d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SetDiff1d.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -57,7 +57,7 @@
  * @param <U> data type for {@code idx()} output
  */
 @Operator
-public final class SetDiff1d<T extends TType, U extends TNumber> extends PrimitiveOp {
+public final class SetDiff1d<T extends TType, U extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SetDiff1d operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SetSize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SetSize.java
index 52c944254ba..bd666afe4b2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SetSize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SetSize.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * indices.
  */
 @Operator
-public final class SetSize extends PrimitiveOp implements Operand<TInt32> {
+public final class SetSize extends RawOp implements Operand<TInt32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.SetSize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Shape.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Shape.java
index bfe5f3ea12c..aef7aec2816 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Shape.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Shape.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -45,7 +45,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class Shape<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class Shape<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Shape operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ShapeN.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ShapeN.java
index b8bc6df4dc5..307e86b38a2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ShapeN.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ShapeN.java
@@ -26,7 +26,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class ShapeN<U extends TNumber> extends PrimitiveOp implements Iterable<Operand<U>> {
+public final class ShapeN<U extends TNumber> extends RawOp implements Iterable<Operand<U>> {
   
   /**
    * Factory method to create a class wrapping a new ShapeN operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Size.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Size.java
index a5d9554ad7e..d79f317a591 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Size.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Size.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -46,7 +46,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class Size<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class Size<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Size operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Skipgram.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Skipgram.java
index 727e501f204..cef935f3389 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Skipgram.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Skipgram.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * Parses a text file and creates a batch of examples.
  */
 @Operator
-public final class Skipgram extends PrimitiveOp {
+public final class Skipgram extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Skipgram}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Slice.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Slice.java
index a20a06271a2..e141b0a2243 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Slice.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Slice.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Slice<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Slice<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Slice operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Snapshot.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Snapshot.java
index 9b095bbe601..8599dac37e6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Snapshot.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Snapshot.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Snapshot<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Snapshot<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Snapshot operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SpaceToBatchNd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SpaceToBatchNd.java
index 049f216bcde..80e9a72e37f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SpaceToBatchNd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SpaceToBatchNd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class SpaceToBatchNd<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SpaceToBatchNd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SpaceToBatchNd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Split.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Split.java
index 5614bb2cd27..f810c353427 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Split.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Split.java
@@ -24,7 +24,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Split<T extends TType> extends PrimitiveOp implements Iterable<Operand<T>> {
+public final class Split<T extends TType> extends RawOp implements Iterable<Operand<T>> {
   
   /**
    * Factory method to create a class wrapping a new Split operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SplitV.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SplitV.java
index 8e05dc84167..49646eecfc2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SplitV.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SplitV.java
@@ -24,7 +24,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class SplitV<T extends TType> extends PrimitiveOp implements Iterable<Operand<T>> {
+public final class SplitV<T extends TType> extends RawOp implements Iterable<Operand<T>> {
   
   /**
    * Factory method to create a class wrapping a new SplitV operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Squeeze.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Squeeze.java
index bf32e738776..5bc2ba50645 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Squeeze.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Squeeze.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -51,7 +51,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Squeeze<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Squeeze<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Squeeze}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Stack.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Stack.java
index faebdfa191b..6e98ac9ab4b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Stack.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Stack.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -52,7 +52,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Stack<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Stack<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Stack}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Stage.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Stage.java
index f7beea8d46f..c741a3ae391 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Stage.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Stage.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * fewer capabilities and options.  This Op is optimized for performance.
  */
 @Operator
-public final class Stage extends PrimitiveOp {
+public final class Stage extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Stage}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StageClear.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StageClear.java
index b2ddbfe320c..ebe153dab5e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StageClear.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StageClear.java
@@ -21,7 +21,7 @@
 import org.tensorflow.DataType;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
  * Op removes all elements in the underlying container.
  */
 @Operator
-public final class StageClear extends PrimitiveOp {
+public final class StageClear extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.StageClear}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StagePeek.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StagePeek.java
index 9f22e4c3db8..0d00e7f1db9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StagePeek.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StagePeek.java
@@ -25,7 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * performance.
  */
 @Operator
-public final class StagePeek extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class StagePeek extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.StagePeek}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StageSize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StageSize.java
index 69140f89121..a6069a51690 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StageSize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StageSize.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * Op returns the number of elements in the underlying container.
  */
 @Operator
-public final class StageSize extends PrimitiveOp implements Operand<TInt32> {
+public final class StageSize extends RawOp implements Operand<TInt32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.StageSize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StopGradient.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StopGradient.java
index 235223edab0..f884e7b98f7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StopGradient.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StopGradient.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -58,7 +58,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class StopGradient<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class StopGradient<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new StopGradient operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StridedSlice.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StridedSlice.java
index d38f9abd2b3..e19467389c2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StridedSlice.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StridedSlice.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -121,7 +121,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class StridedSlice<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class StridedSlice<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.StridedSlice}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StridedSliceAssign.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StridedSliceAssign.java
index af05235111d..e89e6657ad7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StridedSliceAssign.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StridedSliceAssign.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class StridedSliceAssign<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class StridedSliceAssign<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.StridedSliceAssign}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StridedSliceGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StridedSliceGrad.java
index 63eadce5c89..f475104bc81 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StridedSliceGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/StridedSliceGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class StridedSliceGrad<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class StridedSliceGrad<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.StridedSliceGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Sum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Sum.java
index 318b5f3fd26..4fe6e275bad 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Sum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Sum.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Sum<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Sum<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Sum}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SwitchCond.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SwitchCond.java
index ee0132dba29..b0abd4c0d55 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SwitchCond.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/SwitchCond.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code outputFalse()} output
  */
 @Operator
-public final class SwitchCond<T extends TType> extends PrimitiveOp {
+public final class SwitchCond<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SwitchCond operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TemporaryVariable.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TemporaryVariable.java
index 26f98bda02b..e077e34d989 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TemporaryVariable.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TemporaryVariable.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -50,7 +50,7 @@
  * @param <T> data type for {@code ref()} output
  */
 @Operator
-public final class TemporaryVariable<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TemporaryVariable<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TemporaryVariable}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArray.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArray.java
index 114c7660775..ad7f7c482d0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArray.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArray.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * Write data via Write and read via Read or Pack.
  */
 @Operator
-public final class TensorArray extends PrimitiveOp {
+public final class TensorArray extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorArray}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayClose.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayClose.java
index a56f5f791bf..fe58e12dd65 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayClose.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayClose.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * of a step/run.
  */
 @Operator
-public final class TensorArrayClose extends PrimitiveOp {
+public final class TensorArrayClose extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new TensorArrayClose operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayConcat.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayConcat.java
index 496f80f3f4c..3714b8934ca 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayConcat.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayConcat.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class TensorArrayConcat<T extends TType> extends PrimitiveOp {
+public final class TensorArrayConcat<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorArrayConcat}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayGather.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayGather.java
index 7ca239e686f..31980ef9d71 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayGather.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayGather.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class TensorArrayGather<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TensorArrayGather<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorArrayGather}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayGrad.java
index 1c1c85ddaaa..a4cf654bdcc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -68,7 +68,7 @@
  * calculation gets its own TensorArray accumulator.
  */
 @Operator
-public final class TensorArrayGrad extends PrimitiveOp {
+public final class TensorArrayGrad extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new TensorArrayGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayGradWithShape.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayGradWithShape.java
index 0f4d31c6793..7ffbc95fac5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayGradWithShape.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayGradWithShape.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * calculated using the same accumulator.
  */
 @Operator
-public final class TensorArrayGradWithShape extends PrimitiveOp {
+public final class TensorArrayGradWithShape extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new TensorArrayGradWithShape operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayPack.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayPack.java
index 56badd75ac0..ff29972a0f4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayPack.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayPack.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class TensorArrayPack<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TensorArrayPack<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorArrayPack}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayRead.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayRead.java
index c5e3fc45a44..22065261a6a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayRead.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayRead.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class TensorArrayRead<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TensorArrayRead<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorArrayRead operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayScatter.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayScatter.java
index 0529db8d965..f31f6b1428a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayScatter.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayScatter.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * `indices` must be a vector, its length must match the first dim of `value`.
  */
 @Operator
-public final class TensorArrayScatter extends PrimitiveOp implements Operand<TFloat32> {
+public final class TensorArrayScatter extends RawOp implements Operand<TFloat32> {
   
   /**
    * Factory method to create a class wrapping a new TensorArrayScatter operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArraySize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArraySize.java
index be5f11e8066..89642346996 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArraySize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArraySize.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * Get the current size of the TensorArray.
  */
 @Operator
-public final class TensorArraySize extends PrimitiveOp implements Operand<TInt32> {
+public final class TensorArraySize extends RawOp implements Operand<TInt32> {
   
   /**
    * Factory method to create a class wrapping a new TensorArraySize operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArraySplit.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArraySplit.java
index 9de0d6cee5c..ca755929b77 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArraySplit.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArraySplit.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -55,7 +55,7 @@
  * 
  */
 @Operator
-public final class TensorArraySplit extends PrimitiveOp implements Operand<TFloat32> {
+public final class TensorArraySplit extends RawOp implements Operand<TFloat32> {
   
   /**
    * Factory method to create a class wrapping a new TensorArraySplit operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayUnpack.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayUnpack.java
index fa79f698e45..7d9e2b68ae1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayUnpack.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayUnpack.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
 /**
  */
 @Operator
-public final class TensorArrayUnpack extends PrimitiveOp implements Operand<TFloat32> {
+public final class TensorArrayUnpack extends RawOp implements Operand<TFloat32> {
   
   /**
    * Factory method to create a class wrapping a new TensorArrayUnpack operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayWrite.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayWrite.java
index ebbab506030..8f5c56e524a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayWrite.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorArrayWrite.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * Push an element onto the tensor_array.
  */
 @Operator
-public final class TensorArrayWrite extends PrimitiveOp implements Operand<TFloat32> {
+public final class TensorArrayWrite extends RawOp implements Operand<TFloat32> {
   
   /**
    * Factory method to create a class wrapping a new TensorArrayWrite operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestCreateTreeVariable.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestCreateTreeVariable.java
index 014388689c5..ec0df709465 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestCreateTreeVariable.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestCreateTreeVariable.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
 /**
  * Creates a tree resource and returns a handle to it.
  */
-public final class TensorForestCreateTreeVariable extends PrimitiveOp {
+public final class TensorForestCreateTreeVariable extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new TensorForestCreateTreeVariable operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeDeserialize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeDeserialize.java
index 5668528c24a..a7585be7577 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeDeserialize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeDeserialize.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
 /**
  * Deserializes a proto into the tree handle
  */
-public final class TensorForestTreeDeserialize extends PrimitiveOp {
+public final class TensorForestTreeDeserialize extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new TensorForestTreeDeserialize operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeIsInitializedOp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeIsInitializedOp.java
index 62b51ca3864..d0c39ab0de9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeIsInitializedOp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeIsInitializedOp.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Checks whether a tree has been initialized.
  */
-public final class TensorForestTreeIsInitializedOp extends PrimitiveOp implements Operand<TBool> {
+public final class TensorForestTreeIsInitializedOp extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new TensorForestTreeIsInitializedOp operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreePredict.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreePredict.java
index 4f26de9f977..3b8dc79c2d9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreePredict.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreePredict.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Output the logits for the given input data
  */
-public final class TensorForestTreePredict extends PrimitiveOp implements Operand<TFloat32> {
+public final class TensorForestTreePredict extends RawOp implements Operand<TFloat32> {
   
   /**
    * Factory method to create a class wrapping a new TensorForestTreePredict operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeResourceHandleOp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeResourceHandleOp.java
index ab9f32b5c17..f56d34d8df0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeResourceHandleOp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeResourceHandleOp.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Creates a handle to a TensorForestTreeResource
  */
-public final class TensorForestTreeResourceHandleOp extends PrimitiveOp implements Operand<TType> {
+public final class TensorForestTreeResourceHandleOp extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorForestTreeResourceHandleOp}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeSerialize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeSerialize.java
index 8c34e9667a6..07838bb9028 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeSerialize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeSerialize.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Serializes the tree handle to a proto
  */
-public final class TensorForestTreeSerialize extends PrimitiveOp implements Operand<TString> {
+public final class TensorForestTreeSerialize extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new TensorForestTreeSerialize operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeSize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeSize.java
index af36b20df37..03eddda317e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeSize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorForestTreeSize.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Get the number of nodes in a tree
  */
-public final class TensorForestTreeSize extends PrimitiveOp implements Operand<TInt32> {
+public final class TensorForestTreeSize extends RawOp implements Operand<TInt32> {
   
   /**
    * Factory method to create a class wrapping a new TensorForestTreeSize operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListConcat.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListConcat.java
index f359866b643..249e6a07b1d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListConcat.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListConcat.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -49,7 +49,7 @@
  * @param <U> data type for {@code tensor()} output
  */
 @Operator
-public final class TensorListConcat<U extends TType> extends PrimitiveOp {
+public final class TensorListConcat<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new TensorListConcat operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListConcatLists.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListConcatLists.java
index 0f8becf641a..3d685a10b34 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListConcatLists.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListConcatLists.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
 /**
  */
 @Operator
-public final class TensorListConcatLists extends PrimitiveOp implements Operand<TType> {
+public final class TensorListConcatLists extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListConcatLists operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListElementShape.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListElementShape.java
index d673012a769..4115dfebda5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListElementShape.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListElementShape.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code elementShape()} output
  */
 @Operator
-public final class TensorListElementShape<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class TensorListElementShape<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorListElementShape operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListFromTensor.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListFromTensor.java
index 2cbb338ad7b..8569b6b936c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListFromTensor.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListFromTensor.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * output_handle: The list.
  */
 @Operator
-public final class TensorListFromTensor extends PrimitiveOp implements Operand<TType> {
+public final class TensorListFromTensor extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListFromTensor operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListGather.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListGather.java
index 51921cb403f..4c78f491a1a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListGather.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListGather.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code values()} output
  */
 @Operator
-public final class TensorListGather<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TensorListGather<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorListGather operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListGetItem.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListGetItem.java
index 59fd42724a9..1ee5e084768 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListGetItem.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListGetItem.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code item()} output
  */
 @Operator
-public final class TensorListGetItem<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TensorListGetItem<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorListGetItem operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListLength.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListLength.java
index eaadb96b036..c901d022f64 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListLength.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListLength.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * length: the number of tensors in the list
  */
 @Operator
-public final class TensorListLength extends PrimitiveOp implements Operand<TInt32> {
+public final class TensorListLength extends RawOp implements Operand<TInt32> {
   
   /**
    * Factory method to create a class wrapping a new TensorListLength operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListPopBack.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListPopBack.java
index 04f82d310e9..f4fb817b2fc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListPopBack.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListPopBack.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code tensor()} output
  */
 @Operator
-public final class TensorListPopBack<T extends TType> extends PrimitiveOp {
+public final class TensorListPopBack<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new TensorListPopBack operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListPushBack.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListPushBack.java
index c39f1f39e69..216a5d44c4b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListPushBack.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListPushBack.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * element_shape: a shape compatible with that of elements in the list.
  */
 @Operator
-public final class TensorListPushBack extends PrimitiveOp implements Operand<TType> {
+public final class TensorListPushBack extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListPushBack operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListPushBackBatch.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListPushBackBatch.java
index a2079a6e7f4..065e7d0b6ed 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListPushBackBatch.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListPushBackBatch.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  */
 @Operator
-public final class TensorListPushBackBatch extends PrimitiveOp implements Operand<TType> {
+public final class TensorListPushBackBatch extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListPushBackBatch operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListReserve.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListReserve.java
index 0905b6f6d17..0c3294795c1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListReserve.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListReserve.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * element_dtype: the desired type of elements in the list.
  */
 @Operator
-public final class TensorListReserve extends PrimitiveOp implements Operand<TType> {
+public final class TensorListReserve extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListReserve operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListResize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListResize.java
index b0738ac11b9..fb0380aa5a7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListResize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListResize.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * 
  */
 @Operator
-public final class TensorListResize extends PrimitiveOp implements Operand<TType> {
+public final class TensorListResize extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListResize operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListScatter.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListScatter.java
index 40c4b0f7155..12fd2667321 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListScatter.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListScatter.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -45,7 +45,7 @@
  * output_handle: The TensorList.
  */
 @Operator
-public final class TensorListScatter extends PrimitiveOp implements Operand<TType> {
+public final class TensorListScatter extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListScatter operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListScatterIntoExistingList.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListScatterIntoExistingList.java
index 57bdc475a49..4d8d27ed14a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListScatterIntoExistingList.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListScatterIntoExistingList.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * output_handle: The TensorList.
  */
 @Operator
-public final class TensorListScatterIntoExistingList extends PrimitiveOp implements Operand<TType> {
+public final class TensorListScatterIntoExistingList extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListScatterIntoExistingList operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListSetItem.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListSetItem.java
index 4cab1741a0c..d570a3083a4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListSetItem.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListSetItem.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
 /**
  */
 @Operator
-public final class TensorListSetItem extends PrimitiveOp implements Operand<TType> {
+public final class TensorListSetItem extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListSetItem operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListSplit.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListSplit.java
index 7c5344c0f21..aed272880fb 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListSplit.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListSplit.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * output_handle: The list.
  */
 @Operator
-public final class TensorListSplit extends PrimitiveOp implements Operand<TType> {
+public final class TensorListSplit extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListSplit operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListStack.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListStack.java
index 6de9c232757..95075e1bb6d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListStack.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorListStack.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code tensor()} output
  */
 @Operator
-public final class TensorListStack<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TensorListStack<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorListStack}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorScatterNdAdd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorScatterNdAdd.java
index a3d7a01c5e7..77ffefde6f5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorScatterNdAdd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorScatterNdAdd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -93,7 +93,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class TensorScatterNdAdd<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TensorScatterNdAdd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorScatterNdAdd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorScatterNdSub.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorScatterNdSub.java
index 69a77fa35c7..307a2d4b801 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorScatterNdSub.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorScatterNdSub.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -93,7 +93,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class TensorScatterNdSub<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TensorScatterNdSub<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorScatterNdSub operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorScatterNdUpdate.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorScatterNdUpdate.java
index 62b8eb58cf5..500bc416f1c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorScatterNdUpdate.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorScatterNdUpdate.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -104,7 +104,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class TensorScatterNdUpdate<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TensorScatterNdUpdate<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorScatterNdUpdate operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorStridedSliceUpdate.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorStridedSliceUpdate.java
index 9613330e35d..d3bf1403073 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorStridedSliceUpdate.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TensorStridedSliceUpdate.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class TensorStridedSliceUpdate<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TensorStridedSliceUpdate<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorStridedSliceUpdate}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Tile.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Tile.java
index 7b9df6d7c83..abd9d462993 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Tile.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Tile.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -61,7 +61,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Tile<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Tile<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Tile operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Timestamp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Timestamp.java
index 04500bc531d..ef460f466cd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Timestamp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Timestamp.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * to the graph.
  */
 @Operator
-public final class Timestamp extends PrimitiveOp implements Operand<TFloat64> {
+public final class Timestamp extends RawOp implements Operand<TFloat64> {
   
   /**
    * Factory method to create a class wrapping a new Timestamp operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TryRpc.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TryRpc.java
index ac18e0cd9c6..acb69b45d48 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TryRpc.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/TryRpc.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -78,7 +78,7 @@
  * not fail; the rest of the entries will have empty strings.
  */
 @Operator
-public final class TryRpc extends PrimitiveOp {
+public final class TryRpc extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TryRpc}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Unbatch.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Unbatch.java
index 57fba6681b3..5cb23e99e7e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Unbatch.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Unbatch.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -53,7 +53,7 @@
  * @param <T> data type for {@code unbatchedTensor()} output
  */
 @Operator
-public final class Unbatch<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Unbatch<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Unbatch}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/UnbatchGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/UnbatchGrad.java
index f8ef58c8e01..1309c7e80c8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/UnbatchGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/UnbatchGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code batchedGrad()} output
  */
 @Operator
-public final class UnbatchGrad<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class UnbatchGrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.UnbatchGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Unique.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Unique.java
index 87506597c91..9f203229625 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Unique.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Unique.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -77,7 +77,7 @@
  * @param <V> data type for {@code idx()} output
  */
 @Operator
-public final class Unique<T extends TType, V extends TNumber> extends PrimitiveOp {
+public final class Unique<T extends TType, V extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new Unique operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/UniqueWithCounts.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/UniqueWithCounts.java
index 850e40b68ed..a98e6736594 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/UniqueWithCounts.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/UniqueWithCounts.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -81,7 +81,7 @@
  * @param <V> data type for {@code idx()} output
  */
 @Operator
-public final class UniqueWithCounts<T extends TType, V extends TNumber> extends PrimitiveOp {
+public final class UniqueWithCounts<T extends TType, V extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new UniqueWithCounts operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/UnravelIndex.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/UnravelIndex.java
index 8626ad1260a..e272d05ec2a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/UnravelIndex.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/UnravelIndex.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -53,7 +53,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class UnravelIndex<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class UnravelIndex<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new UnravelIndex operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Unstack.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Unstack.java
index 197b63a0009..fcf759828b7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Unstack.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Unstack.java
@@ -24,7 +24,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Unstack<T extends TType> extends PrimitiveOp implements Iterable<Operand<T>> {
+public final class Unstack<T extends TType> extends RawOp implements Iterable<Operand<T>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Unstack}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Unstage.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Unstage.java
index e57b3bf2a4e..806d2d451c4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Unstage.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Unstage.java
@@ -25,7 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * capabilities and options.  This Op is optimized for performance.
  */
 @Operator
-public final class Unstage extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class Unstage extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Unstage}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/UpperBound.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/UpperBound.java
index 585cf116334..375c26ae867 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/UpperBound.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/UpperBound.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -53,7 +53,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class UpperBound<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class UpperBound<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new UpperBound operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/VarHandleOp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/VarHandleOp.java
index 9024268508a..89cb40c41d5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/VarHandleOp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/VarHandleOp.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * Creates a handle to a Variable resource.
  */
 @Operator
-public final class VarHandleOp extends PrimitiveOp implements Operand<TType> {
+public final class VarHandleOp extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.VarHandleOp}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/VarIsInitializedOp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/VarIsInitializedOp.java
index e673381ecf1..0aaf43a2f1b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/VarIsInitializedOp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/VarIsInitializedOp.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Checks whether a resource handle-based variable has been initialized.
  */
 @Operator
-public final class VarIsInitializedOp extends PrimitiveOp implements Operand<TBool> {
+public final class VarIsInitializedOp extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new VarIsInitializedOp operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Variable.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Variable.java
index e2bc0260467..de4af903d9e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Variable.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Variable.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code ref()} output
  */
 @Operator
-public final class Variable<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Variable<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Variable}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/VariableShape.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/VariableShape.java
index 2a178ccf318..76fb3c770d0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/VariableShape.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/VariableShape.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class VariableShape<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class VariableShape<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new VariableShape operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Where.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Where.java
index c92c8337661..2e22fe12311 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Where.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/Where.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -92,7 +92,7 @@
  * 
  */
 @Operator
-public final class Where extends PrimitiveOp implements Operand<TInt64> {
+public final class Where extends RawOp implements Operand<TInt64> {
   
   /**
    * Factory method to create a class wrapping a new Where operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ZerosLike.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ZerosLike.java
index de7a1aa5c86..60767fe78bf 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ZerosLike.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/ZerosLike.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class ZerosLike<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ZerosLike<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ZerosLike operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AnonymousIterator.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AnonymousIterator.java
index efc42766e58..5342aa53303 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AnonymousIterator.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AnonymousIterator.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
 /**
  * A container for an iterator resource.
  */
-public final class AnonymousIterator extends PrimitiveOp {
+public final class AnonymousIterator extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new AnonymousIterator operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AnonymousMemoryCache.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AnonymousMemoryCache.java
index 99d320a48f2..d76e74fdf14 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AnonymousMemoryCache.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AnonymousMemoryCache.java
@@ -20,14 +20,14 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 
 /**
  */
-public final class AnonymousMemoryCache extends PrimitiveOp {
+public final class AnonymousMemoryCache extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new AnonymousMemoryCache operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AnonymousMultiDeviceIterator.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AnonymousMultiDeviceIterator.java
index b67a88a19c5..6f9b8f15f93 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AnonymousMultiDeviceIterator.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AnonymousMultiDeviceIterator.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
 /**
  * A container for a multi device iterator resource.
  */
-public final class AnonymousMultiDeviceIterator extends PrimitiveOp {
+public final class AnonymousMultiDeviceIterator extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new AnonymousMultiDeviceIterator operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AssertNextDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AssertNextDataset.java
index f814ebecda0..219744cd0ea 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AssertNextDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AssertNextDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * means that the check happens <i>after</i> any static optimizations are applied
  * to the dataset graph.
  */
-public final class AssertNextDataset extends PrimitiveOp implements Operand<TType> {
+public final class AssertNextDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new AssertNextDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AutoShardDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AutoShardDataset.java
index 5272826fffe..0146ac37514 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AutoShardDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/AutoShardDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * This dataset will throw a NotFound error if we cannot shard the dataset
  * automatically.
  */
-public final class AutoShardDataset extends PrimitiveOp implements Operand<TType> {
+public final class AutoShardDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.AutoShardDataset}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/BatchDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/BatchDataset.java
index 48206ca8269..eed1ce1e4fb 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/BatchDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/BatchDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
 /**
  * Creates a dataset that batches `batch_size` elements from `input_dataset`.
  */
-public final class BatchDataset extends PrimitiveOp implements Operand<TType> {
+public final class BatchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.BatchDataset}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/BytesProducedStatsDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/BytesProducedStatsDataset.java
index 4d3727072f1..36d1191207f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/BytesProducedStatsDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/BytesProducedStatsDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Records the bytes size of each element of `input_dataset` in a StatsAggregator.
  */
-public final class BytesProducedStatsDataset extends PrimitiveOp implements Operand<TType> {
+public final class BytesProducedStatsDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new BytesProducedStatsDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/CSVDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/CSVDataset.java
index 3bc198a8b50..b49c466acb7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/CSVDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/CSVDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
 
 /**
  */
-public final class CSVDataset extends PrimitiveOp implements Operand<TType> {
+public final class CSVDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new CSVDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/CacheDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/CacheDataset.java
index df75b994cfa..52a52c01eb1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/CacheDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/CacheDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * (e.g. cannot be opened, contains tensors of the wrong shape / size), an error
  * will the returned when used.
  */
-public final class CacheDataset extends PrimitiveOp implements Operand<TType> {
+public final class CacheDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new CacheDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/CacheDatasetV2.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/CacheDatasetV2.java
index fb44f187520..ece63b27c59 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/CacheDatasetV2.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/CacheDatasetV2.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 
 /**
  */
-public final class CacheDatasetV2 extends PrimitiveOp implements Operand<TType> {
+public final class CacheDatasetV2 extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new CacheDatasetV2 operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ChooseFastestDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ChooseFastestDataset.java
index a277593c1af..d0c234e0ba3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ChooseFastestDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ChooseFastestDataset.java
@@ -24,7 +24,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 
 /**
  */
-public final class ChooseFastestDataset extends PrimitiveOp implements Operand<TType> {
+public final class ChooseFastestDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new ChooseFastestDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ConcatenateDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ConcatenateDataset.java
index 8a0d94c0eec..ee7ea7f8684 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ConcatenateDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ConcatenateDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * Creates a dataset that concatenates `input_dataset` with `another_dataset`.
  */
-public final class ConcatenateDataset extends PrimitiveOp implements Operand<TType> {
+public final class ConcatenateDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new ConcatenateDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetCardinality.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetCardinality.java
index 8723b19e0f4..44d118b6d32 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetCardinality.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetCardinality.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * <p>
  * Returns the cardinality of `input_dataset`.
  */
-public final class DatasetCardinality extends PrimitiveOp implements Operand<TInt64> {
+public final class DatasetCardinality extends RawOp implements Operand<TInt64> {
   
   /**
    * Factory method to create a class wrapping a new DatasetCardinality operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetFromGraph.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetFromGraph.java
index 20a80640fd2..fa931c0cd72 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetFromGraph.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetFromGraph.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * <p>
  * Creates a dataset from the provided `graph_def`.
  */
-public final class DatasetFromGraph extends PrimitiveOp implements Operand<TType> {
+public final class DatasetFromGraph extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new DatasetFromGraph operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetToGraph.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetToGraph.java
index e5db83e41d0..908aea9eb42 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetToGraph.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetToGraph.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * <p>
  * Returns a graph representation for `input_dataset`.
  */
-public final class DatasetToGraph extends PrimitiveOp implements Operand<TString> {
+public final class DatasetToGraph extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.DatasetToGraph}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetToSingleElement.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetToSingleElement.java
index da62a9e1e8a..6193b962314 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetToSingleElement.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetToSingleElement.java
@@ -25,7 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
 /**
  * Outputs the single element from the given dataset.
  */
-public final class DatasetToSingleElement extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class DatasetToSingleElement extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new DatasetToSingleElement operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetToTfRecord.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetToTfRecord.java
index cff78662034..237f73b12a3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetToTfRecord.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DatasetToTfRecord.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
 /**
  * Writes the given dataset to the given file using the TFRecord format.
  */
-public final class DatasetToTfRecord extends PrimitiveOp {
+public final class DatasetToTfRecord extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new DatasetToTfRecord operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DeleteIterator.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DeleteIterator.java
index c7858bb9f6e..497d4580763 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DeleteIterator.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DeleteIterator.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -28,7 +28,7 @@
 /**
  * A container for an iterator resource.
  */
-public final class DeleteIterator extends PrimitiveOp {
+public final class DeleteIterator extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new DeleteIterator operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DeleteMemoryCache.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DeleteMemoryCache.java
index 632fd8e38d0..06077aae830 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DeleteMemoryCache.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DeleteMemoryCache.java
@@ -20,14 +20,14 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 
 /**
  */
-public final class DeleteMemoryCache extends PrimitiveOp {
+public final class DeleteMemoryCache extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new DeleteMemoryCache operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DeleteMultiDeviceIterator.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DeleteMultiDeviceIterator.java
index 744d4118de3..5786255bfa5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DeleteMultiDeviceIterator.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DeleteMultiDeviceIterator.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
 /**
  * A container for an iterator resource.
  */
-public final class DeleteMultiDeviceIterator extends PrimitiveOp {
+public final class DeleteMultiDeviceIterator extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new DeleteMultiDeviceIterator operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DenseToSparseBatchDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DenseToSparseBatchDataset.java
index e07ee9bb3f8..8132334935c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DenseToSparseBatchDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DenseToSparseBatchDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Creates a dataset that batches input elements into a SparseTensor.
  */
-public final class DenseToSparseBatchDataset extends PrimitiveOp implements Operand<TType> {
+public final class DenseToSparseBatchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new DenseToSparseBatchDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DeserializeIterator.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DeserializeIterator.java
index 00b4f9fbfc9..a8c05b2d5ad 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DeserializeIterator.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DeserializeIterator.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
  * Converts the given variant tensor to an iterator and stores it in the given resource.
  */
 @Operator(group = "data")
-public final class DeserializeIterator extends PrimitiveOp {
+public final class DeserializeIterator extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new DeserializeIterator operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DirectedInterleaveDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DirectedInterleaveDataset.java
index 316e137581c..229dcc30be2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DirectedInterleaveDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/DirectedInterleaveDataset.java
@@ -24,7 +24,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * A substitute for `InterleaveDataset` on a fixed list of `N` datasets.
  */
-public final class DirectedInterleaveDataset extends PrimitiveOp implements Operand<TType> {
+public final class DirectedInterleaveDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new DirectedInterleaveDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/FilterByLastComponentDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/FilterByLastComponentDataset.java
index 872c9afa81d..9534608a571 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/FilterByLastComponentDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/FilterByLastComponentDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * Creates a dataset containing elements of first component of `input_dataset` having true in the last component.
  */
-public final class FilterByLastComponentDataset extends PrimitiveOp implements Operand<TType> {
+public final class FilterByLastComponentDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new FilterByLastComponentDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/FixedLengthRecordDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/FixedLengthRecordDataset.java
index 624ff67c563..47dbcf7c9ab 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/FixedLengthRecordDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/FixedLengthRecordDataset.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
 
 /**
  */
-public final class FixedLengthRecordDataset extends PrimitiveOp implements Operand<TType> {
+public final class FixedLengthRecordDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new FixedLengthRecordDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IgnoreErrorsDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IgnoreErrorsDataset.java
index 26930ed0c5e..a93cf631b35 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IgnoreErrorsDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IgnoreErrorsDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * Creates a dataset that contains the elements of `input_dataset` ignoring errors.
  */
-public final class IgnoreErrorsDataset extends PrimitiveOp implements Operand<TType> {
+public final class IgnoreErrorsDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new IgnoreErrorsDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/Iterator.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/Iterator.java
index c4b43e28bc5..e56c6743d3c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/Iterator.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/Iterator.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
 
 /**
  */
-public final class Iterator extends PrimitiveOp implements Operand<TType> {
+public final class Iterator extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new Iterator operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorFromStringHandle.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorFromStringHandle.java
index c44e888189d..2a4427a2cae 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorFromStringHandle.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorFromStringHandle.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 
 /**
  */
-public final class IteratorFromStringHandle extends PrimitiveOp implements Operand<TType> {
+public final class IteratorFromStringHandle extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.IteratorFromStringHandle}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorGetDevice.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorGetDevice.java
index 638f56fa411..d1ac024b6b2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorGetDevice.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorGetDevice.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Returns the name of the device on which `resource` has been placed.
  */
-public final class IteratorGetDevice extends PrimitiveOp implements Operand<TString> {
+public final class IteratorGetDevice extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new IteratorGetDevice operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorGetNext.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorGetNext.java
index ae720558bf5..b9aa8731cf9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorGetNext.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorGetNext.java
@@ -25,7 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * Gets the next output from the given iterator .
  */
 @Operator(group = "data")
-public final class IteratorGetNext extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class IteratorGetNext extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new IteratorGetNext operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorGetNextAsOptional.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorGetNextAsOptional.java
index 79fe603eb01..c05f7de1da1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorGetNextAsOptional.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorGetNextAsOptional.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * Gets the next output from the given iterator as an Optional variant.
  */
 @Operator(group = "data")
-public final class IteratorGetNextAsOptional extends PrimitiveOp implements Operand<TType> {
+public final class IteratorGetNextAsOptional extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new IteratorGetNextAsOptional operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorGetNextSync.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorGetNextSync.java
index 835cc1dfb6d..54529263988 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorGetNextSync.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorGetNextSync.java
@@ -25,7 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * operations (e.g. in eager mode).
  */
 @Operator(group = "data")
-public final class IteratorGetNextSync extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class IteratorGetNextSync extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new IteratorGetNextSync operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorToStringHandle.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorToStringHandle.java
index 43986a27017..19e8fcf2ed4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorToStringHandle.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/IteratorToStringHandle.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Converts the given `resource_handle` representing an iterator to a string.
  */
 @Operator(group = "data")
-public final class IteratorToStringHandle extends PrimitiveOp implements Operand<TString> {
+public final class IteratorToStringHandle extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new IteratorToStringHandle operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/LMDBDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/LMDBDataset.java
index b5d2e948eb3..ed6ed0c2ac4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/LMDBDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/LMDBDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -45,7 +45,7 @@
  * LMDB uses different file formats on big- and little-endian machines.
  * `data.LMDBDataset` can only read files in the format of the host machine.
  */
-public final class LMDBDataset extends PrimitiveOp implements Operand<TType> {
+public final class LMDBDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new LMDBDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/LatencyStatsDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/LatencyStatsDataset.java
index cf37c8c6fd4..6d6f9490ac9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/LatencyStatsDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/LatencyStatsDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Records the latency of producing `input_dataset` elements in a StatsAggregator.
  */
-public final class LatencyStatsDataset extends PrimitiveOp implements Operand<TType> {
+public final class LatencyStatsDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new LatencyStatsDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/LeakyReluGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/LeakyReluGrad.java
index 763fac1aa9a..9832f573eda 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/LeakyReluGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/LeakyReluGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class LeakyReluGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class LeakyReluGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.LeakyReluGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MakeIterator.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MakeIterator.java
index 44ad3ff8399..a2f380b0a49 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MakeIterator.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MakeIterator.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * iterator in `iterator` to the first element of `dataset`.
  */
 @Operator(group = "data")
-public final class MakeIterator extends PrimitiveOp {
+public final class MakeIterator extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new MakeIterator operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MatchingFilesDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MatchingFilesDataset.java
index 73ebbf75bff..6a83be042c6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MatchingFilesDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MatchingFilesDataset.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 
 /**
  */
-public final class MatchingFilesDataset extends PrimitiveOp implements Operand<TType> {
+public final class MatchingFilesDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new MatchingFilesDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MaxIntraOpParallelismDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MaxIntraOpParallelismDataset.java
index dbf4869e7eb..76e9dde31d4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MaxIntraOpParallelismDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MaxIntraOpParallelismDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Creates a dataset that overrides the maximum intra-op parallelism.
  */
-public final class MaxIntraOpParallelismDataset extends PrimitiveOp implements Operand<TType> {
+public final class MaxIntraOpParallelismDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new MaxIntraOpParallelismDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ModelDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ModelDataset.java
index 9d1e99516b3..d63ece9bf33 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ModelDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ModelDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * <p>
  * Identity transformation that models performance.
  */
-public final class ModelDataset extends PrimitiveOp implements Operand<TType> {
+public final class ModelDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.ModelDataset}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIterator.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIterator.java
index 2c0c6ee44f6..3c90c6aa1e1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIterator.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIterator.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * Creates a MultiDeviceIterator resource.
  */
-public final class MultiDeviceIterator extends PrimitiveOp implements Operand<TType> {
+public final class MultiDeviceIterator extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new MultiDeviceIterator operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIteratorFromStringHandle.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIteratorFromStringHandle.java
index d5da7320975..2c65ac3db70 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIteratorFromStringHandle.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIteratorFromStringHandle.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Generates a MultiDeviceIterator resource from its provided string handle.
  */
-public final class MultiDeviceIteratorFromStringHandle extends PrimitiveOp implements Operand<TType> {
+public final class MultiDeviceIteratorFromStringHandle extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.MultiDeviceIteratorFromStringHandle}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIteratorGetNextFromShard.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIteratorGetNextFromShard.java
index e8a3c979d87..104a3de3f4a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIteratorGetNextFromShard.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIteratorGetNextFromShard.java
@@ -25,7 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
 /**
  * Gets next element for the provided shard number.
  */
-public final class MultiDeviceIteratorGetNextFromShard extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class MultiDeviceIteratorGetNextFromShard extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new MultiDeviceIteratorGetNextFromShard operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIteratorInit.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIteratorInit.java
index 1e19c498a49..fec8ee78e0b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIteratorInit.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIteratorInit.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Initializes the multi device iterator with the given dataset.
  */
-public final class MultiDeviceIteratorInit extends PrimitiveOp implements Operand<TInt64> {
+public final class MultiDeviceIteratorInit extends RawOp implements Operand<TInt64> {
   
   /**
    * Factory method to create a class wrapping a new MultiDeviceIteratorInit operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIteratorToStringHandle.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIteratorToStringHandle.java
index 177f6becee1..6f6045a848c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIteratorToStringHandle.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/MultiDeviceIteratorToStringHandle.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Produces a string handle for the given MultiDeviceIterator.
  */
-public final class MultiDeviceIteratorToStringHandle extends PrimitiveOp implements Operand<TString> {
+public final class MultiDeviceIteratorToStringHandle extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new MultiDeviceIteratorToStringHandle operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/NonSerializableDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/NonSerializableDataset.java
index b3687765024..f0c86e6abda 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/NonSerializableDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/NonSerializableDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
 
 /**
  */
-public final class NonSerializableDataset extends PrimitiveOp implements Operand<TType> {
+public final class NonSerializableDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new NonSerializableDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptimizeDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptimizeDataset.java
index 59d8072af30..3034b4462dc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptimizeDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptimizeDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * <p>
  * Creates a dataset by applying optimizations to `input_dataset`.
  */
-public final class OptimizeDataset extends PrimitiveOp implements Operand<TType> {
+public final class OptimizeDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.OptimizeDataset}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptionalFromValue.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptionalFromValue.java
index 2920249f317..7832d3cbd58 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptionalFromValue.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptionalFromValue.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * Constructs an Optional variant from a tuple of tensors.
  */
 @Operator(group = "data")
-public final class OptionalFromValue extends PrimitiveOp implements Operand<TType> {
+public final class OptionalFromValue extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new OptionalFromValue operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptionalGetValue.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptionalGetValue.java
index 387488699fb..fa2884822dd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptionalGetValue.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptionalGetValue.java
@@ -25,7 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * Returns the value stored in an Optional variant or raises an error if none exists.
  */
 @Operator(group = "data")
-public final class OptionalGetValue extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class OptionalGetValue extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new OptionalGetValue operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptionalHasValue.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptionalHasValue.java
index adc40c6c92b..d77f53ff5ca 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptionalHasValue.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptionalHasValue.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Returns true if and only if the given Optional variant has a value.
  */
 @Operator(group = "data")
-public final class OptionalHasValue extends PrimitiveOp implements Operand<TBool> {
+public final class OptionalHasValue extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new OptionalHasValue operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptionalNone.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptionalNone.java
index 3ec0b353cfa..ee871daef2e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptionalNone.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/OptionalNone.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Creates an Optional variant with no value.
  */
 @Operator(group = "data")
-public final class OptionalNone extends PrimitiveOp implements Operand<TType> {
+public final class OptionalNone extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new OptionalNone operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/PaddedBatchDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/PaddedBatchDataset.java
index 0897bbf91d5..14d9b28a5a7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/PaddedBatchDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/PaddedBatchDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
 /**
  * Creates a dataset that batches and pads `batch_size` elements from the input.
  */
-public final class PaddedBatchDataset extends PrimitiveOp implements Operand<TType> {
+public final class PaddedBatchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.PaddedBatchDataset}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/PrefetchDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/PrefetchDataset.java
index 481e55f3a33..e7002d4e1ec 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/PrefetchDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/PrefetchDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Creates a dataset that asynchronously prefetches elements from `input_dataset`.
  */
-public final class PrefetchDataset extends PrimitiveOp implements Operand<TType> {
+public final class PrefetchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.PrefetchDataset}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/PrivateThreadPoolDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/PrivateThreadPoolDataset.java
index ce8c76d04f9..28f831063d7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/PrivateThreadPoolDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/PrivateThreadPoolDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class PrivateThreadPoolDataset extends PrimitiveOp implements Operand<TType> {
+public final class PrivateThreadPoolDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new PrivateThreadPoolDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/RandomDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/RandomDataset.java
index 0ce8980fe4d..ec548730254 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/RandomDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/RandomDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -45,7 +45,7 @@
  * performed is determined by the `experimental_optimization.hoist_random_uniform`
  * option of `tf.data.Options`.
  */
-public final class RandomDataset extends PrimitiveOp implements Operand<TType> {
+public final class RandomDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new RandomDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/RangeDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/RangeDataset.java
index c4786405c38..c6d539bc73d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/RangeDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/RangeDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Creates a dataset with a range of values. Corresponds to python's xrange.
  */
-public final class RangeDataset extends PrimitiveOp implements Operand<TType> {
+public final class RangeDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new RangeDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/RebatchDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/RebatchDataset.java
index f389a516397..344d2289664 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/RebatchDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/RebatchDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * Creates a dataset that changes the batch size of the dataset to current batch
  * size // num_workers.
  */
-public final class RebatchDataset extends PrimitiveOp implements Operand<TType> {
+public final class RebatchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.RebatchDataset}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/RepeatDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/RepeatDataset.java
index 5191d14bc11..bb633c6ec18 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/RepeatDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/RepeatDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Creates a dataset that emits the outputs of `input_dataset` `count` times.
  */
-public final class RepeatDataset extends PrimitiveOp implements Operand<TType> {
+public final class RepeatDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new RepeatDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SamplingDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SamplingDataset.java
index 2f3b6b2314c..617e3395199 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SamplingDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SamplingDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * `experimental_optimization.filter_with_random_uniform_fusion` option of
  * `tf.data.Options`.
  */
-public final class SamplingDataset extends PrimitiveOp implements Operand<TType> {
+public final class SamplingDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SamplingDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SerializeIterator.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SerializeIterator.java
index ca734da95c3..0f65886aa83 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SerializeIterator.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SerializeIterator.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Converts the given `resource_handle` representing an iterator to a variant tensor.
  */
 @Operator(group = "data")
-public final class SerializeIterator extends PrimitiveOp implements Operand<TType> {
+public final class SerializeIterator extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SerializeIterator operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SetStatsAggregatorDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SetStatsAggregatorDataset.java
index c80ee68d69d..f439523b01b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SetStatsAggregatorDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SetStatsAggregatorDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 
 /**
  */
-public final class SetStatsAggregatorDataset extends PrimitiveOp implements Operand<TType> {
+public final class SetStatsAggregatorDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SetStatsAggregatorDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ShardDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ShardDataset.java
index f475bfa50df..8976eb5e880 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ShardDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ShardDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Creates a `Dataset` that includes only 1/`num_shards` of this dataset.
  */
-public final class ShardDataset extends PrimitiveOp implements Operand<TType> {
+public final class ShardDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.ShardDataset}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ShuffleAndRepeatDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ShuffleAndRepeatDataset.java
index a315ef243ad..5cc0722fc10 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ShuffleAndRepeatDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ShuffleAndRepeatDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * <p>
  * pseudorandomly.
  */
-public final class ShuffleAndRepeatDataset extends PrimitiveOp implements Operand<TType> {
+public final class ShuffleAndRepeatDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new ShuffleAndRepeatDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ShuffleDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ShuffleDataset.java
index baecd3712fc..79cc77668fe 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ShuffleDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ShuffleDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 
 /**
  */
-public final class ShuffleDataset extends PrimitiveOp implements Operand<TType> {
+public final class ShuffleDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new ShuffleDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SkipDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SkipDataset.java
index 566179d0775..a4e599cbd68 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SkipDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SkipDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Creates a dataset that skips `count` elements from the `input_dataset`.
  */
-public final class SkipDataset extends PrimitiveOp implements Operand<TType> {
+public final class SkipDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SkipDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SleepDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SleepDataset.java
index de92e97c23e..f19efe33358 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SleepDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SleepDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 
 /**
  */
-public final class SleepDataset extends PrimitiveOp implements Operand<TType> {
+public final class SleepDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SleepDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SlidingWindowDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SlidingWindowDataset.java
index e552ae72054..eb521578e3c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SlidingWindowDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SlidingWindowDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Creates a dataset that passes a sliding window over `input_dataset`.
  */
-public final class SlidingWindowDataset extends PrimitiveOp implements Operand<TType> {
+public final class SlidingWindowDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SlidingWindowDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SnapshotDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SnapshotDataset.java
index 6ae3f0bb21e..104484e195f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SnapshotDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SnapshotDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * If not, it will run the preprocessing pipeline as usual, and write out a
  * snapshot of the data processed for future use.
  */
-public final class SnapshotDataset extends PrimitiveOp implements Operand<TType> {
+public final class SnapshotDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.SnapshotDataset}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SparseTensorSliceDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SparseTensorSliceDataset.java
index 5b1aa578fce..9c45e99c9e3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SparseTensorSliceDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SparseTensorSliceDataset.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
 /**
  * Creates a dataset that splits a SparseTensor into elements row-wise.
  */
-public final class SparseTensorSliceDataset extends PrimitiveOp implements Operand<TType> {
+public final class SparseTensorSliceDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SparseTensorSliceDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SqlDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SqlDataset.java
index 1161f0095fe..3e0586b7747 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SqlDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/SqlDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Creates a dataset that executes a SQL query and emits rows of the result set.
  */
-public final class SqlDataset extends PrimitiveOp implements Operand<TType> {
+public final class SqlDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SqlDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/StatsAggregatorHandle.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/StatsAggregatorHandle.java
index 2865865edce..b96fcb2a07e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/StatsAggregatorHandle.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/StatsAggregatorHandle.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Creates a statistics manager resource.
  */
-public final class StatsAggregatorHandle extends PrimitiveOp implements Operand<TType> {
+public final class StatsAggregatorHandle extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.StatsAggregatorHandle}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TakeDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TakeDataset.java
index 7576b7c4214..e27cced1c0d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TakeDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TakeDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Creates a dataset that contains `count` elements from the `input_dataset`.
  */
-public final class TakeDataset extends PrimitiveOp implements Operand<TType> {
+public final class TakeDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TakeDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TensorDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TensorDataset.java
index ab1ba0a6f36..6da30002088 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TensorDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TensorDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * Creates a dataset that emits `components` as a tuple of tensors once.
  */
-public final class TensorDataset extends PrimitiveOp implements Operand<TType> {
+public final class TensorDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TensorSliceDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TensorSliceDataset.java
index 3a60082bfa5..4f9045fca67 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TensorSliceDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TensorSliceDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * Creates a dataset that emits each dim-0 slice of `components` once.
  */
-public final class TensorSliceDataset extends PrimitiveOp implements Operand<TType> {
+public final class TensorSliceDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorSliceDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TextLineDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TextLineDataset.java
index dbdc7e01312..c1a60729079 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TextLineDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TextLineDataset.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
 /**
  * Creates a dataset that emits the lines of one or more text files.
  */
-public final class TextLineDataset extends PrimitiveOp implements Operand<TType> {
+public final class TextLineDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TextLineDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TfRecordDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TfRecordDataset.java
index 46493d48a6b..3ef011e1629 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TfRecordDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/TfRecordDataset.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
 /**
  * Creates a dataset that emits the records from one or more TFRecord files.
  */
-public final class TfRecordDataset extends PrimitiveOp implements Operand<TType> {
+public final class TfRecordDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TfRecordDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ThreadPoolDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ThreadPoolDataset.java
index 648e9b0bbc4..98d0c71e6f2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ThreadPoolDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ThreadPoolDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class ThreadPoolDataset extends PrimitiveOp implements Operand<TType> {
+public final class ThreadPoolDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new ThreadPoolDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ThreadPoolHandle.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ThreadPoolHandle.java
index 1569f6820c3..9c5ad809be0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ThreadPoolHandle.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ThreadPoolHandle.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class ThreadPoolHandle extends PrimitiveOp implements Operand<TType> {
+public final class ThreadPoolHandle extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.ThreadPoolHandle}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/UnbatchDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/UnbatchDataset.java
index 8e36adb710d..d3041a31579 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/UnbatchDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/UnbatchDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * A dataset that splits the elements of its input into multiple elements.
  */
-public final class UnbatchDataset extends PrimitiveOp implements Operand<TType> {
+public final class UnbatchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new UnbatchDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/UniqueDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/UniqueDataset.java
index da5071e945f..0fb4bfd567f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/UniqueDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/UniqueDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * Creates a dataset that contains the unique elements of `input_dataset`.
  */
-public final class UniqueDataset extends PrimitiveOp implements Operand<TType> {
+public final class UniqueDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new UniqueDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/UnwrapDatasetVariant.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/UnwrapDatasetVariant.java
index 3038119dac9..1ba2fb16027 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/UnwrapDatasetVariant.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/UnwrapDatasetVariant.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
 
 /**
  */
-public final class UnwrapDatasetVariant extends PrimitiveOp implements Operand<TType> {
+public final class UnwrapDatasetVariant extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new UnwrapDatasetVariant operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/WindowDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/WindowDataset.java
index f422e1b286a..c6a537f5053 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/WindowDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/WindowDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
 /**
  * A dataset that creates window datasets from the input dataset.
  */
-public final class WindowDataset extends PrimitiveOp implements Operand<TType> {
+public final class WindowDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new WindowDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/WrapDatasetVariant.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/WrapDatasetVariant.java
index 9770df61f30..94ab283621f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/WrapDatasetVariant.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/WrapDatasetVariant.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
 
 /**
  */
-public final class WrapDatasetVariant extends PrimitiveOp implements Operand<TType> {
+public final class WrapDatasetVariant extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new WrapDatasetVariant operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ZipDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ZipDataset.java
index 29ddbe0b3d9..729942f48db 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ZipDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/ZipDataset.java
@@ -24,7 +24,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * The size of the resulting dataset will match the size of the smallest input
  * dataset, and no error will be raised if input datasets have different sizes.
  */
-public final class ZipDataset extends PrimitiveOp implements Operand<TType> {
+public final class ZipDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new ZipDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/AssertNextDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/AssertNextDataset.java
index 8a08a47ce8b..dae63059040 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/AssertNextDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/AssertNextDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 
 /**
  */
-public final class AssertNextDataset extends PrimitiveOp implements Operand<TType> {
+public final class AssertNextDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new AssertNextDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/AutoShardDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/AutoShardDataset.java
index 933a4947611..d385fcc4ec6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/AutoShardDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/AutoShardDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * This dataset will throw a NotFound error if we cannot shard the dataset
  * automatically.
  */
-public final class AutoShardDataset extends PrimitiveOp implements Operand<TType> {
+public final class AutoShardDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.experimental.AutoShardDataset}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/BytesProducedStatsDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/BytesProducedStatsDataset.java
index c8e6b0cc6a0..2e6445c6022 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/BytesProducedStatsDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/BytesProducedStatsDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Records the bytes size of each element of `input_dataset` in a StatsAggregator.
  */
-public final class BytesProducedStatsDataset extends PrimitiveOp implements Operand<TType> {
+public final class BytesProducedStatsDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new BytesProducedStatsDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/CSVDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/CSVDataset.java
index 8a27bbee797..c1ae3705f7f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/CSVDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/CSVDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
 
 /**
  */
-public final class CSVDataset extends PrimitiveOp implements Operand<TType> {
+public final class CSVDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new CSVDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/ChooseFastestDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/ChooseFastestDataset.java
index 37fbdbcf80d..ffc357c0e64 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/ChooseFastestDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/ChooseFastestDataset.java
@@ -24,7 +24,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 
 /**
  */
-public final class ChooseFastestDataset extends PrimitiveOp implements Operand<TType> {
+public final class ChooseFastestDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new ChooseFastestDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/DatasetCardinality.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/DatasetCardinality.java
index 6be7224637b..290bec84df8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/DatasetCardinality.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/DatasetCardinality.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * <p>
  * Returns the cardinality of `input_dataset`.
  */
-public final class DatasetCardinality extends PrimitiveOp implements Operand<TInt64> {
+public final class DatasetCardinality extends RawOp implements Operand<TInt64> {
   
   /**
    * Factory method to create a class wrapping a new DatasetCardinality operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/DatasetToTFRecord.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/DatasetToTFRecord.java
index 3a24d6b3453..3bb2bc62b4b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/DatasetToTFRecord.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/DatasetToTFRecord.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
 /**
  * Writes the given dataset to the given file using the TFRecord format.
  */
-public final class DatasetToTFRecord extends PrimitiveOp {
+public final class DatasetToTFRecord extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new DatasetToTFRecord operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/DenseToSparseBatchDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/DenseToSparseBatchDataset.java
index 425b9090c18..4b2ba319cd4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/DenseToSparseBatchDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/DenseToSparseBatchDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Creates a dataset that batches input elements into a SparseTensor.
  */
-public final class DenseToSparseBatchDataset extends PrimitiveOp implements Operand<TType> {
+public final class DenseToSparseBatchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new DenseToSparseBatchDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/DirectedInterleaveDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/DirectedInterleaveDataset.java
index ed94d523475..d5451edbc1c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/DirectedInterleaveDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/DirectedInterleaveDataset.java
@@ -24,7 +24,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * A substitute for `InterleaveDataset` on a fixed list of `N` datasets.
  */
-public final class DirectedInterleaveDataset extends PrimitiveOp implements Operand<TType> {
+public final class DirectedInterleaveDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new DirectedInterleaveDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/IgnoreErrorsDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/IgnoreErrorsDataset.java
index d151bdf5bd9..9eb59e7117a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/IgnoreErrorsDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/IgnoreErrorsDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * Creates a dataset that contains the elements of `input_dataset` ignoring errors.
  */
-public final class IgnoreErrorsDataset extends PrimitiveOp implements Operand<TType> {
+public final class IgnoreErrorsDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new IgnoreErrorsDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/IteratorGetDevice.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/IteratorGetDevice.java
index 6ce053ad427..2e19177a58f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/IteratorGetDevice.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/IteratorGetDevice.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Returns the name of the device on which `resource` has been placed.
  */
-public final class IteratorGetDevice extends PrimitiveOp implements Operand<TString> {
+public final class IteratorGetDevice extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new IteratorGetDevice operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/LatencyStatsDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/LatencyStatsDataset.java
index fd61f3a3db9..7b90eb275b6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/LatencyStatsDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/LatencyStatsDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Records the latency of producing `input_dataset` elements in a StatsAggregator.
  */
-public final class LatencyStatsDataset extends PrimitiveOp implements Operand<TType> {
+public final class LatencyStatsDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new LatencyStatsDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/LmdbDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/LmdbDataset.java
index 42e05646401..9df2f7d4968 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/LmdbDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/LmdbDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 
 /**
  */
-public final class LmdbDataset extends PrimitiveOp implements Operand<TType> {
+public final class LmdbDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new LmdbDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/MatchingFilesDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/MatchingFilesDataset.java
index 1fd3e91ccb2..fcd78e95ee7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/MatchingFilesDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/MatchingFilesDataset.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 
 /**
  */
-public final class MatchingFilesDataset extends PrimitiveOp implements Operand<TType> {
+public final class MatchingFilesDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new MatchingFilesDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/MaxIntraOpParallelismDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/MaxIntraOpParallelismDataset.java
index d165882fcf7..eba104b133f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/MaxIntraOpParallelismDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/MaxIntraOpParallelismDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Creates a dataset that overrides the maximum intra-op parallelism.
  */
-public final class MaxIntraOpParallelismDataset extends PrimitiveOp implements Operand<TType> {
+public final class MaxIntraOpParallelismDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new MaxIntraOpParallelismDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/NonSerializableDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/NonSerializableDataset.java
index 4c8775e7b83..744e550a79c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/NonSerializableDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/NonSerializableDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
 
 /**
  */
-public final class NonSerializableDataset extends PrimitiveOp implements Operand<TType> {
+public final class NonSerializableDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new NonSerializableDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/ParseExampleDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/ParseExampleDataset.java
index f0e3b91ca90..dc7496ba65d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/ParseExampleDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/ParseExampleDataset.java
@@ -24,7 +24,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
 /**
  * Transforms `input_dataset` containing `Example` protos as vectors of DT_STRING into a dataset of `Tensor` or `SparseTensor` objects representing the parsed features.
  */
-public final class ParseExampleDataset extends PrimitiveOp implements Operand<TType> {
+public final class ParseExampleDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.experimental.ParseExampleDataset}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/PrivateThreadPoolDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/PrivateThreadPoolDataset.java
index 168bf4da559..5690fac534f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/PrivateThreadPoolDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/PrivateThreadPoolDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class PrivateThreadPoolDataset extends PrimitiveOp implements Operand<TType> {
+public final class PrivateThreadPoolDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new PrivateThreadPoolDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/RandomDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/RandomDataset.java
index 6288b7954c2..1e08b9dd432 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/RandomDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/RandomDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Creates a Dataset that returns pseudorandom numbers.
  */
-public final class RandomDataset extends PrimitiveOp implements Operand<TType> {
+public final class RandomDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new RandomDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/RebatchDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/RebatchDataset.java
index 19061580c79..d73865f4b10 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/RebatchDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/RebatchDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * Creates a dataset that changes the batch size of the dataset to current batch
  * size // num_replicas.
  */
-public final class RebatchDataset extends PrimitiveOp implements Operand<TType> {
+public final class RebatchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.experimental.RebatchDataset}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/SetStatsAggregatorDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/SetStatsAggregatorDataset.java
index 95ce75db908..46e7e759ada 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/SetStatsAggregatorDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/SetStatsAggregatorDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 
 /**
  */
-public final class SetStatsAggregatorDataset extends PrimitiveOp implements Operand<TType> {
+public final class SetStatsAggregatorDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SetStatsAggregatorDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/SleepDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/SleepDataset.java
index b416da01618..028b58df749 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/SleepDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/SleepDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 
 /**
  */
-public final class SleepDataset extends PrimitiveOp implements Operand<TType> {
+public final class SleepDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SleepDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/SlidingWindowDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/SlidingWindowDataset.java
index cf4efa8d4e1..05fb2fe19cc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/SlidingWindowDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/SlidingWindowDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Creates a dataset that passes a sliding window over `input_dataset`.
  */
-public final class SlidingWindowDataset extends PrimitiveOp implements Operand<TType> {
+public final class SlidingWindowDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SlidingWindowDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/SqlDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/SqlDataset.java
index 37950bde4a4..daa3868695f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/SqlDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/SqlDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
 /**
  * Creates a dataset that executes a SQL query and emits rows of the result set.
  */
-public final class SqlDataset extends PrimitiveOp implements Operand<TType> {
+public final class SqlDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SqlDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/StatsAggregatorHandle.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/StatsAggregatorHandle.java
index 9783e94a3c3..e3749bfc10b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/StatsAggregatorHandle.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/StatsAggregatorHandle.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
 
 /**
  */
-public final class StatsAggregatorHandle extends PrimitiveOp implements Operand<TType> {
+public final class StatsAggregatorHandle extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.experimental.StatsAggregatorHandle}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/StatsAggregatorSetSummaryWriter.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/StatsAggregatorSetSummaryWriter.java
index f2aaaf78c7f..44acd09f14c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/StatsAggregatorSetSummaryWriter.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/StatsAggregatorSetSummaryWriter.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -28,7 +28,7 @@
 /**
  * Set a summary_writer_interface to record statistics using given stats_aggregator.
  */
-public final class StatsAggregatorSetSummaryWriter extends PrimitiveOp {
+public final class StatsAggregatorSetSummaryWriter extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new StatsAggregatorSetSummaryWriter operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/StatsAggregatorSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/StatsAggregatorSummary.java
index 6681f830f10..1a4d285dfe3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/StatsAggregatorSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/StatsAggregatorSummary.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Produces a summary of any statistics recorded by the given statistics manager.
  */
-public final class StatsAggregatorSummary extends PrimitiveOp implements Operand<TString> {
+public final class StatsAggregatorSummary extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new StatsAggregatorSummary operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/ThreadPoolDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/ThreadPoolDataset.java
index 42c3aca8be4..26cc99e33dc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/ThreadPoolDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/ThreadPoolDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class ThreadPoolDataset extends PrimitiveOp implements Operand<TType> {
+public final class ThreadPoolDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new ThreadPoolDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/ThreadPoolHandle.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/ThreadPoolHandle.java
index 2ff98a5257d..9a2527ec80e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/ThreadPoolHandle.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/ThreadPoolHandle.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class ThreadPoolHandle extends PrimitiveOp implements Operand<TType> {
+public final class ThreadPoolHandle extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.experimental.ThreadPoolHandle}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/UnbatchDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/UnbatchDataset.java
index af3d5a7ccfb..9618adb8d98 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/UnbatchDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/UnbatchDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * A dataset that splits the elements of its input into multiple elements.
  */
-public final class UnbatchDataset extends PrimitiveOp implements Operand<TType> {
+public final class UnbatchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new UnbatchDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/UniqueDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/UniqueDataset.java
index 0f6a449f321..ad85a16f4d6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/UniqueDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/UniqueDataset.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * Creates a dataset that contains the unique elements of `input_dataset`.
  */
-public final class UniqueDataset extends PrimitiveOp implements Operand<TType> {
+public final class UniqueDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new UniqueDataset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/AsString.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/AsString.java
index 852f87dc96e..bf4c6dcc989 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/AsString.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/AsString.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * tutorial.
  */
 @Operator(group = "dtypes")
-public final class AsString extends PrimitiveOp implements Operand<TString> {
+public final class AsString extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.dtypes.AsString}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/Cast.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/Cast.java
index a0461ff6033..5acd9c542f6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/Cast.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/Cast.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * @param <U> data type for {@code y()} output
  */
 @Operator(group = "dtypes")
-public final class Cast<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class Cast<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.dtypes.Cast}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/Complex.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/Complex.java
index d8351a0aec2..a342009290f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/Complex.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/Complex.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -50,7 +50,7 @@
  * @param <U> data type for {@code out()} output
  */
 @Operator(group = "dtypes")
-public final class Complex<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class Complex<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Complex operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesAggregateStats.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesAggregateStats.java
index 1fd29a50555..8a89bc639ba 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesAggregateStats.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesAggregateStats.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * <p>
  * The summary stats contains gradients and hessians accumulated for each node, feature dimension id and bucket.
  */
-public final class BoostedTreesAggregateStats extends PrimitiveOp implements Operand<TFloat32> {
+public final class BoostedTreesAggregateStats extends RawOp implements Operand<TFloat32> {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesAggregateStats operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesBucketize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesBucketize.java
index 19a6d84cc97..1af298bc2c1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesBucketize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesBucketize.java
@@ -25,7 +25,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * An op that returns a list of float tensors, where each tensor represents the
  * bucketized values for a single feature.
  */
-public final class BoostedTreesBucketize extends PrimitiveOp implements Iterable<Operand<TInt32>> {
+public final class BoostedTreesBucketize extends RawOp implements Iterable<Operand<TInt32>> {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesBucketize operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCalculateBestFeatureSplit.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCalculateBestFeatureSplit.java
index 1e3ad432bc1..795acc395ec 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCalculateBestFeatureSplit.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCalculateBestFeatureSplit.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * <p>
  * The output shapes are compatible in a way that the first dimension of all tensors are the same and equal to the number of possible split nodes for each feature.
  */
-public final class BoostedTreesCalculateBestFeatureSplit extends PrimitiveOp {
+public final class BoostedTreesCalculateBestFeatureSplit extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.estimator.BoostedTreesCalculateBestFeatureSplit}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCalculateBestGainsPerFeature.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCalculateBestGainsPerFeature.java
index 7c5290a376c..8525c94641f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCalculateBestGainsPerFeature.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCalculateBestGainsPerFeature.java
@@ -24,7 +24,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * The length of output lists are all of the same length, `num_features`.
  * The output shapes are compatible in a way that the first dimension of all tensors of all lists are the same and equal to the number of possible split nodes for each feature.
  */
-public final class BoostedTreesCalculateBestGainsPerFeature extends PrimitiveOp {
+public final class BoostedTreesCalculateBestGainsPerFeature extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesCalculateBestGainsPerFeature operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCenterBias.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCenterBias.java
index 57fc95cbd23..e1af20a1f14 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCenterBias.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCenterBias.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
 /**
  * Calculates the prior from the training data (the bias) and fills in the first node with the logits' prior. Returns a boolean indicating whether to continue centering.
  */
-public final class BoostedTreesCenterBias extends PrimitiveOp implements Operand<TBool> {
+public final class BoostedTreesCenterBias extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesCenterBias operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCreateEnsemble.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCreateEnsemble.java
index c8ced109e69..c0c9075f784 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCreateEnsemble.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCreateEnsemble.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Creates a tree ensemble model and returns a handle to it.
  */
-public final class BoostedTreesCreateEnsemble extends PrimitiveOp {
+public final class BoostedTreesCreateEnsemble extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesCreateEnsemble operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCreateQuantileStreamResource.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCreateQuantileStreamResource.java
index 7096b534aaf..d0ac0b0224d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCreateQuantileStreamResource.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCreateQuantileStreamResource.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Create the Resource for Quantile Streams.
  */
-public final class BoostedTreesCreateQuantileStreamResource extends PrimitiveOp {
+public final class BoostedTreesCreateQuantileStreamResource extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.estimator.BoostedTreesCreateQuantileStreamResource}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesDeserializeEnsemble.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesDeserializeEnsemble.java
index e55780dfdd6..8780ca997bd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesDeserializeEnsemble.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesDeserializeEnsemble.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * <p>
  * ensemble.
  */
-public final class BoostedTreesDeserializeEnsemble extends PrimitiveOp {
+public final class BoostedTreesDeserializeEnsemble extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesDeserializeEnsemble operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesEnsembleResourceHandleOp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesEnsembleResourceHandleOp.java
index c04913746ad..d297ccebdb2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesEnsembleResourceHandleOp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesEnsembleResourceHandleOp.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Creates a handle to a BoostedTreesEnsembleResource
  */
-public final class BoostedTreesEnsembleResourceHandleOp extends PrimitiveOp implements Operand<TType> {
+public final class BoostedTreesEnsembleResourceHandleOp extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.estimator.BoostedTreesEnsembleResourceHandleOp}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesExampleDebugOutputs.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesExampleDebugOutputs.java
index d54aae568dd..0abe526d221 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesExampleDebugOutputs.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesExampleDebugOutputs.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * such as getting split feature ids and logits after each split along the decision
  * path used to compute directional feature contributions.
  */
-public final class BoostedTreesExampleDebugOutputs extends PrimitiveOp implements Operand<TString> {
+public final class BoostedTreesExampleDebugOutputs extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesExampleDebugOutputs operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesFlushQuantileSummaries.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesFlushQuantileSummaries.java
index b03db0f9e8d..83191ca1a6a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesFlushQuantileSummaries.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesFlushQuantileSummaries.java
@@ -24,7 +24,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * Each summary Tensor is rank 2, containing summaries (value, weight, min_rank, 
  * max_rank) for a single feature.
  */
-public final class BoostedTreesFlushQuantileSummaries extends PrimitiveOp implements Iterable<Operand<TFloat32>> {
+public final class BoostedTreesFlushQuantileSummaries extends RawOp implements Iterable<Operand<TFloat32>> {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesFlushQuantileSummaries operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesGetEnsembleStates.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesGetEnsembleStates.java
index cbadccfd4a4..06ef0f63bfc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesGetEnsembleStates.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesGetEnsembleStates.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
 /**
  * Retrieves the tree ensemble resource stamp token, number of trees and growing statistics.
  */
-public final class BoostedTreesGetEnsembleStates extends PrimitiveOp {
+public final class BoostedTreesGetEnsembleStates extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesGetEnsembleStates operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesMakeQuantileSummaries.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesMakeQuantileSummaries.java
index b0a1a7468b1..6bdbd64dd7a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesMakeQuantileSummaries.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesMakeQuantileSummaries.java
@@ -25,7 +25,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * An op that takes a list of tensors (one tensor per feature) and outputs the
  * quantile summaries for each tensor.
  */
-public final class BoostedTreesMakeQuantileSummaries extends PrimitiveOp implements Iterable<Operand<TFloat32>> {
+public final class BoostedTreesMakeQuantileSummaries extends RawOp implements Iterable<Operand<TFloat32>> {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesMakeQuantileSummaries operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesMakeStatsSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesMakeStatsSummary.java
index 1a21ef1d12a..ed276f08b20 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesMakeStatsSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesMakeStatsSummary.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * <p>
  * The summary stats contains gradients and hessians accumulated into the corresponding node and bucket for each example.
  */
-public final class BoostedTreesMakeStatsSummary extends PrimitiveOp implements Operand<TFloat32> {
+public final class BoostedTreesMakeStatsSummary extends RawOp implements Operand<TFloat32> {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesMakeStatsSummary operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesPredict.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesPredict.java
index bbaa7b5df6e..fc12d1cc2ed 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesPredict.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesPredict.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * computes the logits. It is designed to be used during prediction.
  * It traverses all the trees and calculates the final score for each instance.
  */
-public final class BoostedTreesPredict extends PrimitiveOp implements Operand<TFloat32> {
+public final class BoostedTreesPredict extends RawOp implements Operand<TFloat32> {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesPredict operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceAddSummaries.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceAddSummaries.java
index 448288b295b..08bda03ea19 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceAddSummaries.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceAddSummaries.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * summary Tensor is rank 2, containing summaries (value, weight, min_rank, max_rank)
  * for a single feature.
  */
-public final class BoostedTreesQuantileStreamResourceAddSummaries extends PrimitiveOp {
+public final class BoostedTreesQuantileStreamResourceAddSummaries extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesQuantileStreamResourceAddSummaries operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceDeserialize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceDeserialize.java
index 2f415ca5c5a..58850d3e981 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceDeserialize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceDeserialize.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * <p>
  * An op that deserializes bucket boundaries and are boundaries ready flag into current QuantileAccumulator.
  */
-public final class BoostedTreesQuantileStreamResourceDeserialize extends PrimitiveOp {
+public final class BoostedTreesQuantileStreamResourceDeserialize extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesQuantileStreamResourceDeserialize operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceFlush.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceFlush.java
index 041adb21898..4f3c4f561b8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceFlush.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceFlush.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * <p>
  * An op that flushes the summaries for a quantile stream resource.
  */
-public final class BoostedTreesQuantileStreamResourceFlush extends PrimitiveOp {
+public final class BoostedTreesQuantileStreamResourceFlush extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.estimator.BoostedTreesQuantileStreamResourceFlush}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceGetBucketBoundaries.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceGetBucketBoundaries.java
index 2f6c7d027cd..711e3f6acd6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceGetBucketBoundaries.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceGetBucketBoundaries.java
@@ -24,7 +24,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * An op that returns a list of float tensors for a quantile stream resource. Each
  * tensor is Rank 1 containing bucket boundaries for a single feature.
  */
-public final class BoostedTreesQuantileStreamResourceGetBucketBoundaries extends PrimitiveOp implements Iterable<Operand<TFloat32>> {
+public final class BoostedTreesQuantileStreamResourceGetBucketBoundaries extends RawOp implements Iterable<Operand<TFloat32>> {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesQuantileStreamResourceGetBucketBoundaries operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceHandleOp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceHandleOp.java
index 499622baa97..72898030449 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceHandleOp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesQuantileStreamResourceHandleOp.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Creates a handle to a BoostedTreesQuantileStreamResource.
  */
-public final class BoostedTreesQuantileStreamResourceHandleOp extends PrimitiveOp implements Operand<TType> {
+public final class BoostedTreesQuantileStreamResourceHandleOp extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.estimator.BoostedTreesQuantileStreamResourceHandleOp}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesSerializeEnsemble.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesSerializeEnsemble.java
index 82fd66a3f01..8bf4df8541e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesSerializeEnsemble.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesSerializeEnsemble.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
 /**
  * Serializes the tree ensemble to a proto.
  */
-public final class BoostedTreesSerializeEnsemble extends PrimitiveOp {
+public final class BoostedTreesSerializeEnsemble extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesSerializeEnsemble operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesSparseAggregateStats.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesSparseAggregateStats.java
index 6cb55d341ad..23ef1f4f01e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesSparseAggregateStats.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesSparseAggregateStats.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * <p>
  * The summary stats contains gradients and hessians accumulated for each node, bucket and dimension id.
  */
-public final class BoostedTreesSparseAggregateStats extends PrimitiveOp {
+public final class BoostedTreesSparseAggregateStats extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesSparseAggregateStats operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesSparseCalculateBestFeatureSplit.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesSparseCalculateBestFeatureSplit.java
index d3e27e3a749..4fd95330a53 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesSparseCalculateBestFeatureSplit.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesSparseCalculateBestFeatureSplit.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * <p>
  * The output shapes are compatible in a way that the first dimension of all tensors are the same and equal to the number of possible split nodes for each feature.
  */
-public final class BoostedTreesSparseCalculateBestFeatureSplit extends PrimitiveOp {
+public final class BoostedTreesSparseCalculateBestFeatureSplit extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.estimator.BoostedTreesSparseCalculateBestFeatureSplit}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesTrainingPredict.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesTrainingPredict.java
index b35cca01a9a..2dd38c35c59 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesTrainingPredict.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesTrainingPredict.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * It traverses the trees starting from cached tree id and cached node id and
  * calculates the updates to be pushed to the cache.
  */
-public final class BoostedTreesTrainingPredict extends PrimitiveOp {
+public final class BoostedTreesTrainingPredict extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesTrainingPredict operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesUpdateEnsemble.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesUpdateEnsemble.java
index 4d2a19a8dac..05f2d9c1357 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesUpdateEnsemble.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesUpdateEnsemble.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * <p>
  * or by starting a new tree.
  */
-public final class BoostedTreesUpdateEnsemble extends PrimitiveOp {
+public final class BoostedTreesUpdateEnsemble extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BoostedTreesUpdateEnsemble operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesUpdateEnsembleV2.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesUpdateEnsembleV2.java
index d23930c3af0..e1d6bb59e1b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesUpdateEnsembleV2.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesUpdateEnsembleV2.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * <p>
  * or by starting a new tree.
  */
-public final class BoostedTreesUpdateEnsembleV2 extends PrimitiveOp {
+public final class BoostedTreesUpdateEnsembleV2 extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.estimator.BoostedTreesUpdateEnsembleV2}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/IsBoostedTreesEnsembleInitialized.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/IsBoostedTreesEnsembleInitialized.java
index 1f607d6ce86..7a42dc4434f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/IsBoostedTreesEnsembleInitialized.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/IsBoostedTreesEnsembleInitialized.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Checks whether a tree ensemble has been initialized.
  */
-public final class IsBoostedTreesEnsembleInitialized extends PrimitiveOp implements Operand<TBool> {
+public final class IsBoostedTreesEnsembleInitialized extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new IsBoostedTreesEnsembleInitialized operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/IsBoostedTreesQuantileStreamResourceInitialized.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/IsBoostedTreesQuantileStreamResourceInitialized.java
index fb553d42dd8..6561f2d1eea 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/IsBoostedTreesQuantileStreamResourceInitialized.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/IsBoostedTreesQuantileStreamResourceInitialized.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * <p>
  * An Op that checks if quantile stream resource is initialized.
  */
-public final class IsBoostedTreesQuantileStreamResourceInitialized extends PrimitiveOp implements Operand<TBool> {
+public final class IsBoostedTreesQuantileStreamResourceInitialized extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new IsBoostedTreesQuantileStreamResourceInitialized operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/AdjustContrast.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/AdjustContrast.java
index 8370ad520d3..acca1abe88b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/AdjustContrast.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/AdjustContrast.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class AdjustContrast<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class AdjustContrast<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new AdjustContrast operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/AdjustHue.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/AdjustHue.java
index 5684acd2bc9..39d96bec97e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/AdjustHue.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/AdjustHue.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class AdjustHue<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class AdjustHue<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new AdjustHue operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/AdjustSaturation.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/AdjustSaturation.java
index 5fc0d0555d3..3fa15fc4716 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/AdjustSaturation.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/AdjustSaturation.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class AdjustSaturation<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class AdjustSaturation<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new AdjustSaturation operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/CombinedNonMaxSuppression.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/CombinedNonMaxSuppression.java
index 8fa9c593b4a..6b8ef483c90 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/CombinedNonMaxSuppression.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/CombinedNonMaxSuppression.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -46,7 +46,7 @@
  * returned after performing non_max_suppression.
  */
 @Operator(group = "image")
-public final class CombinedNonMaxSuppression extends PrimitiveOp {
+public final class CombinedNonMaxSuppression extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.CombinedNonMaxSuppression}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/CropAndResize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/CropAndResize.java
index 6b525de1e6c..19c93f95d4b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/CropAndResize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/CropAndResize.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -50,7 +50,7 @@
  * `align_corners=True`.
  */
 @Operator(group = "image")
-public final class CropAndResize extends PrimitiveOp implements Operand<TFloat32> {
+public final class CropAndResize extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.CropAndResize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/CropAndResizeGradBoxes.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/CropAndResizeGradBoxes.java
index 7e94754182e..e29c2a2c159 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/CropAndResizeGradBoxes.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/CropAndResizeGradBoxes.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * Computes the gradient of the crop_and_resize op wrt the input boxes tensor.
  */
 @Operator(group = "image")
-public final class CropAndResizeGradBoxes extends PrimitiveOp implements Operand<TFloat32> {
+public final class CropAndResizeGradBoxes extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.CropAndResizeGradBoxes}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/CropAndResizeGradImage.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/CropAndResizeGradImage.java
index c1d444615a7..30b7f0b7ddf 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/CropAndResizeGradImage.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/CropAndResizeGradImage.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class CropAndResizeGradImage<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class CropAndResizeGradImage<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.CropAndResizeGradImage}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodeAndCropJpeg.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodeAndCropJpeg.java
index 620cb1cb179..c7191af839a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodeAndCropJpeg.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodeAndCropJpeg.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -58,7 +58,7 @@
  * decoding partial jpeg image.
  */
 @Operator(group = "image")
-public final class DecodeAndCropJpeg extends PrimitiveOp implements Operand<TUint8> {
+public final class DecodeAndCropJpeg extends RawOp implements Operand<TUint8> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.DecodeAndCropJpeg}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodeBmp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodeBmp.java
index 5d033859b4b..23ade8ab9e9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodeBmp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodeBmp.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -46,7 +46,7 @@
  * 4: output an RGBA image.
  */
 @Operator(group = "image")
-public final class DecodeBmp extends PrimitiveOp implements Operand<TUint8> {
+public final class DecodeBmp extends RawOp implements Operand<TUint8> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.DecodeBmp}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodeGif.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodeGif.java
index 6c5e942d114..c61b81f21c2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodeGif.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodeGif.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * `tf.image.decode_image`.
  */
 @Operator(group = "image")
-public final class DecodeGif extends PrimitiveOp implements Operand<TUint8> {
+public final class DecodeGif extends RawOp implements Operand<TUint8> {
   
   /**
    * Factory method to create a class wrapping a new DecodeGif operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodeJpeg.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodeJpeg.java
index 4d44c13ace3..4b30ea87bec 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodeJpeg.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodeJpeg.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -57,7 +57,7 @@
  * the same, though it is cleaner to use `tf.image.decode_image`.
  */
 @Operator(group = "image")
-public final class DecodeJpeg extends PrimitiveOp implements Operand<TUint8> {
+public final class DecodeJpeg extends RawOp implements Operand<TUint8> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.DecodeJpeg}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodePng.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodePng.java
index 8098707c4df..6ff272fc487 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodePng.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DecodePng.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -61,7 +61,7 @@
  * @param <T> data type for {@code image()} output
  */
 @Operator(group = "image")
-public final class DecodePng<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class DecodePng<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.DecodePng}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DrawBoundingBoxes.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DrawBoundingBoxes.java
index d5e6338d9a9..08d460a2985 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DrawBoundingBoxes.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/DrawBoundingBoxes.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -47,7 +47,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class DrawBoundingBoxes<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class DrawBoundingBoxes<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DrawBoundingBoxes operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/EncodeJpeg.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/EncodeJpeg.java
index d0d6c69d1d5..a08e1d0fbc8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/EncodeJpeg.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/EncodeJpeg.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -58,7 +58,7 @@
  * 3: Output an RGB image.
  */
 @Operator(group = "image")
-public final class EncodeJpeg extends PrimitiveOp implements Operand<TString> {
+public final class EncodeJpeg extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.EncodeJpeg}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/EncodeJpegVariableQuality.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/EncodeJpegVariableQuality.java
index dd3d19c6432..8c9fe1afd49 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/EncodeJpegVariableQuality.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/EncodeJpegVariableQuality.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * 
  */
 @Operator(group = "image")
-public final class EncodeJpegVariableQuality extends PrimitiveOp implements Operand<TString> {
+public final class EncodeJpegVariableQuality extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new EncodeJpegVariableQuality operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/EncodePng.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/EncodePng.java
index 3376ce34c9f..0d01ff0f6f4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/EncodePng.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/EncodePng.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -53,7 +53,7 @@
  * the smallest output, but is slower.
  */
 @Operator(group = "image")
-public final class EncodePng extends PrimitiveOp implements Operand<TString> {
+public final class EncodePng extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.EncodePng}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ExtractGlimpse.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ExtractGlimpse.java
index 06ff4eb09ea..74ac3be5a05 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ExtractGlimpse.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ExtractGlimpse.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -59,7 +59,7 @@
  *   numbers of pixels.
  */
 @Operator(group = "image")
-public final class ExtractGlimpse extends PrimitiveOp implements Operand<TFloat32> {
+public final class ExtractGlimpse extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ExtractGlimpse}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ExtractImagePatches.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ExtractImagePatches.java
index 2a359ec336f..0ea0b7b5049 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ExtractImagePatches.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ExtractImagePatches.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code patches()} output
  */
 @Operator(group = "image")
-public final class ExtractImagePatches<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class ExtractImagePatches<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ExtractImagePatches operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ExtractJpegShape.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ExtractJpegShape.java
index 13c33189395..3570c3a6dda 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ExtractJpegShape.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ExtractJpegShape.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code imageShape()} output
  */
 @Operator(group = "image")
-public final class ExtractJpegShape<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class ExtractJpegShape<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ExtractJpegShape operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/GenerateBoundingBoxProposals.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/GenerateBoundingBoxProposals.java
index 14131fd7003..16d71155a66 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/GenerateBoundingBoxProposals.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/GenerateBoundingBoxProposals.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  *       `rois`: output RoIs, a 3D tensor of shape [Batch, post_nms_topn, 4], padded by 0 if less than post_nms_topn candidates found.
  *       `roi_probabilities`: probability scores of each roi in 'rois', a 2D tensor of shape [Batch,post_nms_topn], padded with 0 if needed, sorted by scores.
  */
-public final class GenerateBoundingBoxProposals extends PrimitiveOp {
+public final class GenerateBoundingBoxProposals extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.GenerateBoundingBoxProposals}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/HsvToRgb.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/HsvToRgb.java
index 2f49c1e0194..6a74b96f923 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/HsvToRgb.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/HsvToRgb.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class HsvToRgb<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class HsvToRgb<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new HsvToRgb operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/NearestNeighbors.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/NearestNeighbors.java
index 6fefdc9f350..55eab58c7fc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/NearestNeighbors.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/NearestNeighbors.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * the list of candidate centers. For each point, the k centers that have least L2
  * distance to it are computed.
  */
-public final class NearestNeighbors extends PrimitiveOp {
+public final class NearestNeighbors extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new NearestNeighbors operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/NonMaxSuppression.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/NonMaxSuppression.java
index 3b74c223eb4..ee83c1d3f06 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/NonMaxSuppression.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/NonMaxSuppression.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -58,7 +58,7 @@
  * @param <T> data type for {@code selectedScores()} output
  */
 @Operator(group = "image")
-public final class NonMaxSuppression<T extends TNumber> extends PrimitiveOp {
+public final class NonMaxSuppression<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.NonMaxSuppression}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/NonMaxSuppressionWithOverlaps.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/NonMaxSuppressionWithOverlaps.java
index 3ba14e3590b..97e14206922 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/NonMaxSuppressionWithOverlaps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/NonMaxSuppressionWithOverlaps.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -47,7 +47,7 @@
  *   selected_boxes = tf.gather(boxes, selected_indices)
  */
 @Operator(group = "image")
-public final class NonMaxSuppressionWithOverlaps extends PrimitiveOp implements Operand<TInt32> {
+public final class NonMaxSuppressionWithOverlaps extends RawOp implements Operand<TInt32> {
   
   /**
    * Factory method to create a class wrapping a new NonMaxSuppressionWithOverlaps operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/QuantizedResizeBilinear.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/QuantizedResizeBilinear.java
index 339cec1e8c5..9903ce2c265 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/QuantizedResizeBilinear.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/QuantizedResizeBilinear.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code resizedImages()} output
  */
 @Operator(group = "image")
-public final class QuantizedResizeBilinear<T extends TType> extends PrimitiveOp {
+public final class QuantizedResizeBilinear<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.QuantizedResizeBilinear}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/RandomCrop.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/RandomCrop.java
index 023eff405a3..855a60036d9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/RandomCrop.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/RandomCrop.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class RandomCrop<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class RandomCrop<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.RandomCrop}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeArea.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeArea.java
index 03fa94fc429..dd7d7335570 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeArea.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeArea.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -46,7 +46,7 @@
  * area that intersects the footprint.  This is the same as OpenCV's INTER_AREA.
  */
 @Operator(group = "image")
-public final class ResizeArea extends PrimitiveOp implements Operand<TFloat32> {
+public final class ResizeArea extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ResizeArea}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeBicubic.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeBicubic.java
index 922af4fab71..23fa5034437 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeBicubic.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeBicubic.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * Input images can be of different types but output images are always float.
  */
 @Operator(group = "image")
-public final class ResizeBicubic extends PrimitiveOp implements Operand<TFloat32> {
+public final class ResizeBicubic extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ResizeBicubic}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeBicubicGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeBicubicGrad.java
index aa46a77f7ba..d7cc678f8a4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeBicubicGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeBicubicGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class ResizeBicubicGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class ResizeBicubicGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ResizeBicubicGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeBilinear.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeBilinear.java
index 90cb29dc222..fb01887d6f5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeBilinear.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeBilinear.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * Input images can be of different types but output images are always float.
  */
 @Operator(group = "image")
-public final class ResizeBilinear extends PrimitiveOp implements Operand<TFloat32> {
+public final class ResizeBilinear extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ResizeBilinear}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeBilinearGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeBilinearGrad.java
index 691b21a2d76..85fb0ff85e6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeBilinearGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeBilinearGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class ResizeBilinearGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class ResizeBilinearGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ResizeBilinearGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeNearestNeighbor.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeNearestNeighbor.java
index ef0f0865259..9183dd63544 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeNearestNeighbor.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeNearestNeighbor.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code resizedImages()} output
  */
 @Operator(group = "image")
-public final class ResizeNearestNeighbor<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class ResizeNearestNeighbor<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ResizeNearestNeighbor}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeNearestNeighborGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeNearestNeighborGrad.java
index 7590b2994bd..c8fb4f704f8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeNearestNeighborGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ResizeNearestNeighborGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class ResizeNearestNeighborGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class ResizeNearestNeighborGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ResizeNearestNeighborGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/RgbToHsv.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/RgbToHsv.java
index 5b1bb1da5e8..55f5a3c5045 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/RgbToHsv.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/RgbToHsv.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class RgbToHsv<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class RgbToHsv<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RgbToHsv operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/SampleDistortedBoundingBox.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/SampleDistortedBoundingBox.java
index ab89803e992..8281880a8b0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/SampleDistortedBoundingBox.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/SampleDistortedBoundingBox.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -73,7 +73,7 @@
  * @param <T> data type for {@code begin()} output
  */
 @Operator(group = "image")
-public final class SampleDistortedBoundingBox<T extends TNumber> extends PrimitiveOp {
+public final class SampleDistortedBoundingBox<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.SampleDistortedBoundingBox}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ScaleAndTranslate.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ScaleAndTranslate.java
index 5a808d76cdb..bd4cc964f2f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ScaleAndTranslate.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ScaleAndTranslate.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  */
 @Operator(group = "image")
-public final class ScaleAndTranslate extends PrimitiveOp implements Operand<TFloat32> {
+public final class ScaleAndTranslate extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ScaleAndTranslate}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ScaleAndTranslateGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ScaleAndTranslateGrad.java
index 40de8e8a7d9..8ab90449e1f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ScaleAndTranslateGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ScaleAndTranslateGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
 /**
  * @param <T> data type for {@code output()} output
  */
-public final class ScaleAndTranslateGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class ScaleAndTranslateGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ScaleAndTranslateGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeBase64.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeBase64.java
index 699974b6685..7abe6aaa1f1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeBase64.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeBase64.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * Web-safe means that input must use - and _ instead of + and /.
  */
 @Operator(group = "io")
-public final class DecodeBase64 extends PrimitiveOp implements Operand<TString> {
+public final class DecodeBase64 extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new DecodeBase64 operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeCompressed.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeCompressed.java
index 5de80c21b7a..01a55de64ca 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeCompressed.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeCompressed.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * element in `bytes`.
  */
 @Operator(group = "io")
-public final class DecodeCompressed extends PrimitiveOp implements Operand<TString> {
+public final class DecodeCompressed extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.DecodeCompressed}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeCsv.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeCsv.java
index 40511a71e17..4825645c0eb 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeCsv.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeCsv.java
@@ -25,7 +25,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * Note that we allow leading and trailing spaces with int or float field.
  */
 @Operator(group = "io")
-public final class DecodeCsv extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class DecodeCsv extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.DecodeCsv}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeJsonExample.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeJsonExample.java
index ab7f69b994c..0f5b155c267 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeJsonExample.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeJsonExample.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * Example-parsing ops.
  */
 @Operator(group = "io")
-public final class DecodeJsonExample extends PrimitiveOp implements Operand<TString> {
+public final class DecodeJsonExample extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new DecodeJsonExample operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodePaddedRaw.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodePaddedRaw.java
index 9a6dd000c0d..137f69f7015 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodePaddedRaw.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodePaddedRaw.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "io")
-public final class DecodePaddedRaw<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class DecodePaddedRaw<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.DecodePaddedRaw}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeRaw.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeRaw.java
index 71331fce34f..d42e9e79d6c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeRaw.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DecodeRaw.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "io")
-public final class DecodeRaw<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class DecodeRaw<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.DecodeRaw}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DeserializeManySparse.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DeserializeManySparse.java
index 3284e5ba845..1d80fd486df 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DeserializeManySparse.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/DeserializeManySparse.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -78,7 +78,7 @@
  * @param <T> data type for {@code sparseValues()} output
  */
 @Operator(group = "io")
-public final class DeserializeManySparse<T extends TType> extends PrimitiveOp {
+public final class DeserializeManySparse<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new DeserializeManySparse operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/EncodeBase64.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/EncodeBase64.java
index 8abe452e781..9dbfbb079b2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/EncodeBase64.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/EncodeBase64.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * Web-safe means that the encoder uses - and _ instead of + and /.
  */
 @Operator(group = "io")
-public final class EncodeBase64 extends PrimitiveOp implements Operand<TString> {
+public final class EncodeBase64 extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.EncodeBase64}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/FifoQueue.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/FifoQueue.java
index 608e03ff212..2d2f6bf4cd6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/FifoQueue.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/FifoQueue.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * A queue that produces elements in first-in first-out order.
  */
 @Operator(group = "io")
-public final class FifoQueue extends PrimitiveOp implements Operand<TType> {
+public final class FifoQueue extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.FifoQueue}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/FixedLengthRecordReader.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/FixedLengthRecordReader.java
index 5d1a7466664..a091f665ba4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/FixedLengthRecordReader.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/FixedLengthRecordReader.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * A Reader that outputs fixed-length records from a file.
  */
 @Operator(group = "io")
-public final class FixedLengthRecordReader extends PrimitiveOp implements Operand<TType> {
+public final class FixedLengthRecordReader extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.FixedLengthRecordReader}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/IdentityReader.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/IdentityReader.java
index 13a0c64b19a..af9a6ca34e7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/IdentityReader.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/IdentityReader.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * work string and output (work, work).
  */
 @Operator(group = "io")
-public final class IdentityReader extends PrimitiveOp implements Operand<TType> {
+public final class IdentityReader extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.IdentityReader}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/LmdbReader.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/LmdbReader.java
index 02e0679520a..aa8c476a0c1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/LmdbReader.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/LmdbReader.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * A Reader that outputs the records from a LMDB file.
  */
 @Operator(group = "io")
-public final class LmdbReader extends PrimitiveOp implements Operand<TString> {
+public final class LmdbReader extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.LmdbReader}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/MatchingFiles.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/MatchingFiles.java
index 035496f9f60..5c9d5bcd681 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/MatchingFiles.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/MatchingFiles.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * Note also that the order of filenames returned is deterministic.
  */
 @Operator(group = "io")
-public final class MatchingFiles extends PrimitiveOp implements Operand<TString> {
+public final class MatchingFiles extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new MatchingFiles operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/PaddingFifoQueue.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/PaddingFifoQueue.java
index 9367d892d89..a8bffa8c38c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/PaddingFifoQueue.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/PaddingFifoQueue.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * size of any given element in the minibatch.  See below for details.
  */
 @Operator(group = "io")
-public final class PaddingFifoQueue extends PrimitiveOp implements Operand<TType> {
+public final class PaddingFifoQueue extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.PaddingFifoQueue}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseExample.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseExample.java
index 17285fd0bd8..6344ccadb69 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseExample.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseExample.java
@@ -25,7 +25,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * Transforms a vector of tf.Example protos (as strings) into typed tensors.
  */
 @Operator(group = "io")
-public final class ParseExample extends PrimitiveOp {
+public final class ParseExample extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ParseExample operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseSequenceExample.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseSequenceExample.java
index 261ce985869..b110b6bd68c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseSequenceExample.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseSequenceExample.java
@@ -25,7 +25,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * typed tensors.
  */
 @Operator(group = "io")
-public final class ParseSequenceExample extends PrimitiveOp {
+public final class ParseSequenceExample extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.ParseSequenceExample}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseSingleExample.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseSingleExample.java
index dee872e796a..65163bc0a64 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseSingleExample.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseSingleExample.java
@@ -25,7 +25,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * Transforms a tf.Example proto (as a string) into typed tensors.
  */
 @Operator(group = "io")
-public final class ParseSingleExample extends PrimitiveOp {
+public final class ParseSingleExample extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ParseSingleExample operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseSingleSequenceExample.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseSingleSequenceExample.java
index 362623ecffa..883825ee2f0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseSingleSequenceExample.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseSingleSequenceExample.java
@@ -25,7 +25,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * Transforms a scalar brain.SequenceExample proto (as strings) into typed tensors.
  */
 @Operator(group = "io")
-public final class ParseSingleSequenceExample extends PrimitiveOp {
+public final class ParseSingleSequenceExample extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.ParseSingleSequenceExample}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseTensor.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseTensor.java
index b9c31f1508b..bf2a8e62c2d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseTensor.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ParseTensor.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "io")
-public final class ParseTensor<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ParseTensor<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ParseTensor operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/PriorityQueue.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/PriorityQueue.java
index 56fb114ae8d..56e3013afdf 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/PriorityQueue.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/PriorityQueue.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * entry in their input (resp. output) lists.
  */
 @Operator(group = "io")
-public final class PriorityQueue extends PrimitiveOp implements Operand<TType> {
+public final class PriorityQueue extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.PriorityQueue}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueClose.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueClose.java
index a7711794244..d2bbb349ec0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueClose.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueClose.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * operations that would block will fail immediately.
  */
 @Operator(group = "io")
-public final class QueueClose extends PrimitiveOp {
+public final class QueueClose extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.QueueClose}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueDequeue.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueDequeue.java
index 2bd4b7a4583..d5c2f67db77 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueDequeue.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueDequeue.java
@@ -25,7 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * has been dequeued (or 'timeout_ms' elapses, if specified).
  */
 @Operator(group = "io")
-public final class QueueDequeue extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class QueueDequeue extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.QueueDequeue}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueDequeueMany.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueDequeueMany.java
index fb270466691..f705e660c1b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueDequeueMany.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueDequeueMany.java
@@ -25,7 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -50,7 +50,7 @@
  * have been dequeued (or 'timeout_ms' elapses, if specified).
  */
 @Operator(group = "io")
-public final class QueueDequeueMany extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class QueueDequeueMany extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.QueueDequeueMany}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueDequeueUpTo.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueDequeueUpTo.java
index 1dec0ae69e0..cd1406318ef 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueDequeueUpTo.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueDequeueUpTo.java
@@ -25,7 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -54,7 +54,7 @@
  * component of the dequeued tuple.
  */
 @Operator(group = "io")
-public final class QueueDequeueUpTo extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class QueueDequeueUpTo extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.QueueDequeueUpTo}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueEnqueue.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueEnqueue.java
index 39ba03a0be5..8bbe35eeada 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueEnqueue.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueEnqueue.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * element has been enqueued (or 'timeout_ms' elapses, if specified).
  */
 @Operator(group = "io")
-public final class QueueEnqueue extends PrimitiveOp {
+public final class QueueEnqueue extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.QueueEnqueue}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueEnqueueMany.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueEnqueueMany.java
index 2a2c72042fc..8f973f62260 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueEnqueueMany.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueEnqueueMany.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * elements have been enqueued (or 'timeout_ms' elapses, if specified).
  */
 @Operator(group = "io")
-public final class QueueEnqueueMany extends PrimitiveOp {
+public final class QueueEnqueueMany extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.QueueEnqueueMany}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueIsClosed.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueIsClosed.java
index 337fb27e770..0326250f5a5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueIsClosed.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueIsClosed.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * is open.
  */
 @Operator(group = "io")
-public final class QueueIsClosed extends PrimitiveOp implements Operand<TBool> {
+public final class QueueIsClosed extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new QueueIsClosed operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueSize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueSize.java
index 72a0edfe446..cf904be8436 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueSize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/QueueSize.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Computes the number of elements in the given queue.
  */
 @Operator(group = "io")
-public final class QueueSize extends PrimitiveOp implements Operand<TInt32> {
+public final class QueueSize extends RawOp implements Operand<TInt32> {
   
   /**
    * Factory method to create a class wrapping a new QueueSize operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/RandomShuffleQueue.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/RandomShuffleQueue.java
index 584c68bfa7b..3f9dc375583 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/RandomShuffleQueue.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/RandomShuffleQueue.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * A queue that randomizes the order of elements.
  */
 @Operator(group = "io")
-public final class RandomShuffleQueue extends PrimitiveOp implements Operand<TType> {
+public final class RandomShuffleQueue extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.RandomShuffleQueue}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReadFile.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReadFile.java
index 5226775b1bb..9ba806c69ae 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReadFile.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReadFile.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Reads and outputs the entire contents of the input filename.
  */
 @Operator(group = "io")
-public final class ReadFile extends PrimitiveOp implements Operand<TString> {
+public final class ReadFile extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new ReadFile operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderNumRecordsProduced.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderNumRecordsProduced.java
index 4a1a97a2a50..51ec23956fb 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderNumRecordsProduced.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderNumRecordsProduced.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * succeeded.
  */
 @Operator(group = "io")
-public final class ReaderNumRecordsProduced extends PrimitiveOp implements Operand<TInt64> {
+public final class ReaderNumRecordsProduced extends RawOp implements Operand<TInt64> {
   
   /**
    * Factory method to create a class wrapping a new ReaderNumRecordsProduced operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderNumWorkUnitsCompleted.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderNumWorkUnitsCompleted.java
index 846cf33af5b..848f1602cb3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderNumWorkUnitsCompleted.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderNumWorkUnitsCompleted.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Returns the number of work units this Reader has finished processing.
  */
 @Operator(group = "io")
-public final class ReaderNumWorkUnitsCompleted extends PrimitiveOp implements Operand<TInt64> {
+public final class ReaderNumWorkUnitsCompleted extends RawOp implements Operand<TInt64> {
   
   /**
    * Factory method to create a class wrapping a new ReaderNumWorkUnitsCompleted operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderRead.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderRead.java
index c2155f7076e..33e1e7135e5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderRead.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderRead.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * with the previous file).
  */
 @Operator(group = "io")
-public final class ReaderRead extends PrimitiveOp {
+public final class ReaderRead extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ReaderRead operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderReadUpTo.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderReadUpTo.java
index 46cd31fdebc..897ca83dc9f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderReadUpTo.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderReadUpTo.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * It may return less than `num_records` even before the last batch.
  */
 @Operator(group = "io")
-public final class ReaderReadUpTo extends PrimitiveOp {
+public final class ReaderReadUpTo extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ReaderReadUpTo operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderReset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderReset.java
index 5358b464440..f99a25a836a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderReset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderReset.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
  * Restore a Reader to its initial clean state.
  */
 @Operator(group = "io")
-public final class ReaderReset extends PrimitiveOp {
+public final class ReaderReset extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ReaderReset operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderRestoreState.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderRestoreState.java
index ccd2626d42f..359c4d63284 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderRestoreState.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderRestoreState.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * Unimplemented error.
  */
 @Operator(group = "io")
-public final class ReaderRestoreState extends PrimitiveOp {
+public final class ReaderRestoreState extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ReaderRestoreState operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderSerializeState.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderSerializeState.java
index dc3870da199..d10ce99d2a8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderSerializeState.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ReaderSerializeState.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * Unimplemented error.
  */
 @Operator(group = "io")
-public final class ReaderSerializeState extends PrimitiveOp implements Operand<TString> {
+public final class ReaderSerializeState extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new ReaderSerializeState operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/SerializeManySparse.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/SerializeManySparse.java
index fcfb4d610b0..5cb65e873cc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/SerializeManySparse.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/SerializeManySparse.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * @param <U> data type for {@code serializedSparse()} output
  */
 @Operator(group = "io")
-public final class SerializeManySparse<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class SerializeManySparse<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new SerializeManySparse operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/SerializeSparse.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/SerializeSparse.java
index 208c5c7f08c..d97317b00d4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/SerializeSparse.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/SerializeSparse.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <U> data type for {@code serializedSparse()} output
  */
 @Operator(group = "io")
-public final class SerializeSparse<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class SerializeSparse<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new SerializeSparse operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/SerializeTensor.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/SerializeTensor.java
index d4c9935cd0a..07935a57d3f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/SerializeTensor.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/SerializeTensor.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * Transforms a Tensor into a serialized TensorProto proto.
  */
 @Operator(group = "io")
-public final class SerializeTensor extends PrimitiveOp implements Operand<TString> {
+public final class SerializeTensor extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new SerializeTensor operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ShardedFilename.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ShardedFilename.java
index 67f46a9070b..3febe213066 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ShardedFilename.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ShardedFilename.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  *    %s-%05d-of-%05d, basename, shard, num_shards.
  */
 @Operator(group = "io")
-public final class ShardedFilename extends PrimitiveOp implements Operand<TString> {
+public final class ShardedFilename extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new ShardedFilename operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ShardedFilespec.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ShardedFilespec.java
index 28083c719dc..4c414afa0a4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ShardedFilespec.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/ShardedFilespec.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * Generate a glob pattern matching all sharded file names.
  */
 @Operator(group = "io")
-public final class ShardedFilespec extends PrimitiveOp implements Operand<TString> {
+public final class ShardedFilespec extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new ShardedFilespec operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/TextLineReader.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/TextLineReader.java
index 2bf90570a63..963710a3708 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/TextLineReader.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/TextLineReader.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * A Reader that outputs the lines of a file delimited by '\n'.
  */
 @Operator(group = "io")
-public final class TextLineReader extends PrimitiveOp implements Operand<TType> {
+public final class TextLineReader extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.TextLineReader}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/TfRecordReader.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/TfRecordReader.java
index fcfe302590a..98d58836334 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/TfRecordReader.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/TfRecordReader.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * A Reader that outputs the records from a TensorFlow Records file.
  */
 @Operator(group = "io")
-public final class TfRecordReader extends PrimitiveOp implements Operand<TType> {
+public final class TfRecordReader extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.TfRecordReader}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/WholeFileReader.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/WholeFileReader.java
index f09432be41a..444b36aec72 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/WholeFileReader.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/WholeFileReader.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * be a filename (key) and the contents of that file (value).
  */
 @Operator(group = "io")
-public final class WholeFileReader extends PrimitiveOp implements Operand<TType> {
+public final class WholeFileReader extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.WholeFileReader}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/WriteFile.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/WriteFile.java
index ef8a07a64d4..2d8f1ed4a1b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/WriteFile.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/io/WriteFile.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * creates directory if not existing.
  */
 @Operator(group = "io")
-public final class WriteFile extends PrimitiveOp {
+public final class WriteFile extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new WriteFile operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BandPart.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BandPart.java
index fa035634e2b..6c4cc2cddba 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BandPart.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BandPart.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -72,7 +72,7 @@
  * @param <T> data type for {@code band()} output
  */
 @Operator(group = "linalg")
-public final class BandPart<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class BandPart<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BandPart operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchCholesky.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchCholesky.java
index a895bab00ef..988d5a23c7f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchCholesky.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchCholesky.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchCholesky<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class BatchCholesky<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchCholesky operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchCholeskyGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchCholeskyGrad.java
index bd718574b73..71b533674a8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchCholeskyGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchCholeskyGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchCholeskyGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class BatchCholeskyGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchCholeskyGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixBandPart.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixBandPart.java
index 7e9ece57b3a..7b0a946e593 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixBandPart.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixBandPart.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * @param <T> data type for {@code band()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixBandPart<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class BatchMatrixBandPart<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchMatrixBandPart operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixDeterminant.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixDeterminant.java
index c28b9a32d86..c56dcebd836 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixDeterminant.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixDeterminant.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixDeterminant<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class BatchMatrixDeterminant<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchMatrixDeterminant operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixDiag.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixDiag.java
index f8957df0175..3cb73f6e451 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixDiag.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixDiag.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixDiag<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class BatchMatrixDiag<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchMatrixDiag operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixDiagPart.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixDiagPart.java
index 005211352ca..99207f83e9c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixDiagPart.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixDiagPart.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * @param <T> data type for {@code diagonal()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixDiagPart<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class BatchMatrixDiagPart<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchMatrixDiagPart operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixInverse.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixInverse.java
index 4f067575bca..bf8ca469f95 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixInverse.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixInverse.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixInverse<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class BatchMatrixInverse<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchMatrixInverse}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixSetDiag.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixSetDiag.java
index 9d75d28cf1d..7f8508edbb0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixSetDiag.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixSetDiag.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixSetDiag<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class BatchMatrixSetDiag<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchMatrixSetDiag operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixSolve.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixSolve.java
index c4411bd4f98..a4b086faa3f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixSolve.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixSolve.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixSolve<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class BatchMatrixSolve<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchMatrixSolve}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixSolveLs.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixSolveLs.java
index d905525752f..c5a71d9481d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixSolveLs.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixSolveLs.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixSolveLs<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class BatchMatrixSolveLs<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchMatrixSolveLs}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixTriangularSolve.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixTriangularSolve.java
index 2104d4253de..186d68a8f68 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixTriangularSolve.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchMatrixTriangularSolve.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixTriangularSolve<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class BatchMatrixTriangularSolve<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchMatrixTriangularSolve}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchSelfAdjointEig.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchSelfAdjointEig.java
index 3718089820f..d2c56803f3a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchSelfAdjointEig.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchSelfAdjointEig.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * @param <T> data type for {@code e()} output
  */
 @Operator(group = "linalg")
-public final class BatchSelfAdjointEig<T extends TNumber> extends PrimitiveOp {
+public final class BatchSelfAdjointEig<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchSelfAdjointEig}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchSvd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchSvd.java
index ea3a18844c3..25b8da69ab5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchSvd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/BatchSvd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * @param <T> data type for {@code s()} output
  */
 @Operator(group = "linalg")
-public final class BatchSvd<T extends TType> extends PrimitiveOp {
+public final class BatchSvd<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchSvd}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Cholesky.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Cholesky.java
index 4bbb9845705..64216a5a5d3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Cholesky.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Cholesky.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -47,7 +47,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Cholesky<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Cholesky<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Cholesky operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/CholeskyGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/CholeskyGrad.java
index 94524a7f78b..e60c7eee5fd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/CholeskyGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/CholeskyGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class CholeskyGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class CholeskyGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new CholeskyGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/ConjugateTranspose.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/ConjugateTranspose.java
index f237e43edeb..a1d82fd5d07 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/ConjugateTranspose.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/ConjugateTranspose.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "linalg")
-public final class ConjugateTranspose<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ConjugateTranspose<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ConjugateTranspose operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Cross.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Cross.java
index 9fdf6738b86..1de44ceb714 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Cross.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Cross.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code product()} output
  */
 @Operator(group = "linalg")
-public final class Cross<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Cross<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Cross operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Det.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Det.java
index 3246fa9f684..4ae18c47148 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Det.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Det.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Det<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Det<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Det operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Eig.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Eig.java
index 22f74d80fe0..faaf6dd5972 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Eig.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Eig.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -46,7 +46,7 @@
  * @param <U> data type for {@code e()} output
  */
 @Operator(group = "linalg")
-public final class Eig<U extends TType> extends PrimitiveOp {
+public final class Eig<U extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.Eig}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Einsum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Einsum.java
index 3b9669f1162..2fcb505b7bf 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Einsum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Einsum.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -111,7 +111,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Einsum<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Einsum<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Einsum operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/EuclideanNorm.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/EuclideanNorm.java
index 7e4620a4767..eeb65943fa3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/EuclideanNorm.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/EuclideanNorm.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class EuclideanNorm<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class EuclideanNorm<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.EuclideanNorm}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Inv.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Inv.java
index 089e3e3e980..46fbed05b63 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Inv.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Inv.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Inv<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Inv<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.Inv}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/LoadAndRemapMatrix.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/LoadAndRemapMatrix.java
index 650b45a57b9..58482665ed7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/LoadAndRemapMatrix.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/LoadAndRemapMatrix.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -74,7 +74,7 @@
  *  [0.25,    -0.25,      42]]
  */
 @Operator(group = "linalg")
-public final class LoadAndRemapMatrix extends PrimitiveOp implements Operand<TFloat32> {
+public final class LoadAndRemapMatrix extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.LoadAndRemapMatrix}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/LogMatrixDeterminant.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/LogMatrixDeterminant.java
index f6f0bdb738d..a19e1753007 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/LogMatrixDeterminant.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/LogMatrixDeterminant.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code sign()} output
  */
 @Operator(group = "linalg")
-public final class LogMatrixDeterminant<T extends TType> extends PrimitiveOp {
+public final class LogMatrixDeterminant<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new LogMatrixDeterminant operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Lu.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Lu.java
index f27ff3273de..f243cc902c9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Lu.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Lu.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -55,7 +55,7 @@
  * @param <U> data type for {@code p()} output
  */
 @Operator(group = "linalg")
-public final class Lu<T extends TType, U extends TNumber> extends PrimitiveOp {
+public final class Lu<T extends TType, U extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new Lu operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatMul.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatMul.java
index 619de5ea849..72466aaceea 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatMul.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatMul.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code product()} output
  */
 @Operator(group = "linalg")
-public final class MatMul<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class MatMul<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.MatMul}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiag.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiag.java
index 0b7fbf0c89e..97e885f95e8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiag.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiag.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -119,7 +119,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class MatrixDiag<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class MatrixDiag<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new MatrixDiag operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagPart.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagPart.java
index bbe08d49c68..81a80bb0d5c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagPart.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagPart.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -101,7 +101,7 @@
  * @param <T> data type for {@code diagonal()} output
  */
 @Operator(group = "linalg")
-public final class MatrixDiagPart<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class MatrixDiagPart<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new MatrixDiagPart operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixLogarithm.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixLogarithm.java
index 0ca0381dcca..ba6adbaf0aa 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixLogarithm.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixLogarithm.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class MatrixLogarithm<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class MatrixLogarithm<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new MatrixLogarithm operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixSetDiag.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixSetDiag.java
index c34ccb9edf3..e96e8dc678c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixSetDiag.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixSetDiag.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -103,7 +103,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class MatrixSetDiag<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class MatrixSetDiag<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new MatrixSetDiag operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixSolveLs.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixSolveLs.java
index 4bdbad110ec..cf4f910788a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixSolveLs.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixSolveLs.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -69,7 +69,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class MatrixSolveLs<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class MatrixSolveLs<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.MatrixSolveLs}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Qr.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Qr.java
index ae25d48a5c2..e35661a5ae4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Qr.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Qr.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code q()} output
  */
 @Operator(group = "linalg")
-public final class Qr<T extends TType> extends PrimitiveOp {
+public final class Qr<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.Qr}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/QuantizedMatMul.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/QuantizedMatMul.java
index c85ff8fc946..749ba329ea1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/QuantizedMatMul.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/QuantizedMatMul.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * @param <V> data type for {@code out()} output
  */
 @Operator(group = "linalg")
-public final class QuantizedMatMul<V extends TType> extends PrimitiveOp {
+public final class QuantizedMatMul<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.QuantizedMatMul}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/QuantizedMatMulWithBias.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/QuantizedMatMulWithBias.java
index 24cd9b92fae..48ac255e7a5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/QuantizedMatMulWithBias.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/QuantizedMatMulWithBias.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * 
  * @param <W> data type for {@code out()} output
  */
-public final class QuantizedMatMulWithBias<W extends TType> extends PrimitiveOp {
+public final class QuantizedMatMulWithBias<W extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.QuantizedMatMulWithBias}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/QuantizedMatMulWithBiasAndRelu.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/QuantizedMatMulWithBiasAndRelu.java
index 4442ba75b00..6958b14a7f3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/QuantizedMatMulWithBiasAndRelu.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/QuantizedMatMulWithBiasAndRelu.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * 
  * @param <V> data type for {@code out()} output
  */
-public final class QuantizedMatMulWithBiasAndRelu<V extends TType> extends PrimitiveOp {
+public final class QuantizedMatMulWithBiasAndRelu<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.QuantizedMatMulWithBiasAndRelu}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/QuantizedMatMulWithBiasAndReluAndRequantize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/QuantizedMatMulWithBiasAndReluAndRequantize.java
index 6983d67690b..17d2b2a25d0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/QuantizedMatMulWithBiasAndReluAndRequantize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/QuantizedMatMulWithBiasAndReluAndRequantize.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * 
  * @param <W> data type for {@code out()} output
  */
-public final class QuantizedMatMulWithBiasAndReluAndRequantize<W extends TType> extends PrimitiveOp {
+public final class QuantizedMatMulWithBiasAndReluAndRequantize<W extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.QuantizedMatMulWithBiasAndReluAndRequantize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/SelfAdjointEig.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/SelfAdjointEig.java
index d9231cc2e3d..d0d3e8f4f5f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/SelfAdjointEig.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/SelfAdjointEig.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code e()} output
  */
 @Operator(group = "linalg")
-public final class SelfAdjointEig<T extends TType> extends PrimitiveOp {
+public final class SelfAdjointEig<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.SelfAdjointEig}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Solve.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Solve.java
index 9bb164a734b..087b8ef7991 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Solve.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Solve.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Solve<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Solve<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.Solve}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Sqrtm.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Sqrtm.java
index c7b62f8f532..865732f0d16 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Sqrtm.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Sqrtm.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Sqrtm<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Sqrtm<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sqrtm operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Svd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Svd.java
index 401dbd19122..df0772367fd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Svd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Svd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code s()} output
  */
 @Operator(group = "linalg")
-public final class Svd<T extends TType> extends PrimitiveOp {
+public final class Svd<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.Svd}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TensorDiag.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TensorDiag.java
index 9cc58010f7c..40bf987f815 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TensorDiag.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TensorDiag.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -51,7 +51,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class TensorDiag<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TensorDiag<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorDiag operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TensorDiagPart.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TensorDiagPart.java
index 940321abeed..c14b82af064 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TensorDiagPart.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TensorDiagPart.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -52,7 +52,7 @@
  * @param <T> data type for {@code diagonal()} output
  */
 @Operator(group = "linalg")
-public final class TensorDiagPart<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TensorDiagPart<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorDiagPart operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Transpose.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Transpose.java
index 99083a2e05d..5ce582563ea 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Transpose.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/Transpose.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "linalg")
-public final class Transpose<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Transpose<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Transpose operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TriangularSolve.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TriangularSolve.java
index becfd3e9d34..a8c647dda72 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TriangularSolve.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TriangularSolve.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -78,7 +78,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class TriangularSolve<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TriangularSolve<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.TriangularSolve}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TridiagonalMatMul.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TridiagonalMatMul.java
index b18b7b964cc..219e9305eaa 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TridiagonalMatMul.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TridiagonalMatMul.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class TridiagonalMatMul<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TridiagonalMatMul<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TridiagonalMatMul operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TridiagonalSolve.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TridiagonalSolve.java
index aa5286bc3d6..0ad614e24d2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TridiagonalSolve.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/TridiagonalSolve.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class TridiagonalSolve<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TridiagonalSolve<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.TridiagonalSolve}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/CSRSparseMatrixComponents.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/CSRSparseMatrixComponents.java
index bbfb9dbd574..01e7c156baf 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/CSRSparseMatrixComponents.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/CSRSparseMatrixComponents.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * 
  * @param <T> data type for {@code values()} output
  */
-public final class CSRSparseMatrixComponents<T extends TType> extends PrimitiveOp {
+public final class CSRSparseMatrixComponents<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new CSRSparseMatrixComponents operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/CSRSparseMatrixToDense.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/CSRSparseMatrixToDense.java
index 46d43a1f464..f221c56fce1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/CSRSparseMatrixToDense.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/CSRSparseMatrixToDense.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * 
  * @param <T> data type for {@code denseOutput()} output
  */
-public final class CSRSparseMatrixToDense<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class CSRSparseMatrixToDense<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new CSRSparseMatrixToDense operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/CSRSparseMatrixToSparseTensor.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/CSRSparseMatrixToSparseTensor.java
index 4f87c6424da..2a3ec8c2c71 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/CSRSparseMatrixToSparseTensor.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/CSRSparseMatrixToSparseTensor.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code values()} output
  */
 @Operator(group = "linalg.sparse")
-public final class CSRSparseMatrixToSparseTensor<T extends TType> extends PrimitiveOp {
+public final class CSRSparseMatrixToSparseTensor<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new CSRSparseMatrixToSparseTensor operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/DenseToCSRSparseMatrix.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/DenseToCSRSparseMatrix.java
index 9fee7faa4f6..032f2f82cb6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/DenseToCSRSparseMatrix.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/DenseToCSRSparseMatrix.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * Converts a dense tensor to a (possibly batched) CSRSparseMatrix.
  */
 @Operator(group = "linalg.sparse")
-public final class DenseToCSRSparseMatrix extends PrimitiveOp implements Operand<TType> {
+public final class DenseToCSRSparseMatrix extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new DenseToCSRSparseMatrix operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixAdd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixAdd.java
index a7305e79640..41815f021c0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixAdd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixAdd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * currently defined (TensorFlow will return zeros for these entries).
  */
 @Operator(group = "linalg.sparse")
-public final class SparseMatrixAdd extends PrimitiveOp implements Operand<TType> {
+public final class SparseMatrixAdd extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixAdd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixMatMul.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixMatMul.java
index 15055f24bcc..ea5bb99ff6b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixMatMul.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixMatMul.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -58,7 +58,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg.sparse")
-public final class SparseMatrixMatMul<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SparseMatrixMatMul<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.sparse.SparseMatrixMatMul}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixMul.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixMul.java
index 30480ae57aa..94fb2a9bb62 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixMul.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixMul.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * change.
  */
 @Operator(group = "linalg.sparse")
-public final class SparseMatrixMul extends PrimitiveOp implements Operand<TType> {
+public final class SparseMatrixMul extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixMul operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixNNZ.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixNNZ.java
index 6e32756313e..3c52da6f99f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixNNZ.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixNNZ.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Returns the number of nonzeroes of `sparse_matrix`.
  */
 @Operator(group = "linalg.sparse")
-public final class SparseMatrixNNZ extends PrimitiveOp implements Operand<TInt32> {
+public final class SparseMatrixNNZ extends RawOp implements Operand<TInt32> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixNNZ operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixOrderingAMD.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixOrderingAMD.java
index 3099d1d2876..9a21a20a1be 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixOrderingAMD.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixOrderingAMD.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -79,7 +79,7 @@
  * input: A `CSRSparseMatrix`.
  */
 @Operator(group = "linalg.sparse")
-public final class SparseMatrixOrderingAMD extends PrimitiveOp implements Operand<TInt32> {
+public final class SparseMatrixOrderingAMD extends RawOp implements Operand<TInt32> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixOrderingAMD operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixSoftmax.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixSoftmax.java
index 29c6a4d8e51..6fc71595b7d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixSoftmax.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixSoftmax.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * in the output may now be treated as having probability zero).
  */
 @Operator(group = "linalg.sparse")
-public final class SparseMatrixSoftmax extends PrimitiveOp implements Operand<TType> {
+public final class SparseMatrixSoftmax extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixSoftmax operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixSoftmaxGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixSoftmaxGrad.java
index aca62d787cf..7dbb04a18a2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixSoftmaxGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixSoftmaxGrad.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * Calculates the gradient of the SparseMatrixSoftmax op.
  */
 @Operator(group = "linalg.sparse")
-public final class SparseMatrixSoftmaxGrad extends PrimitiveOp implements Operand<TType> {
+public final class SparseMatrixSoftmaxGrad extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixSoftmaxGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixSparseCholesky.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixSparseCholesky.java
index ce766b67918..6373992e173 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixSparseCholesky.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixSparseCholesky.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -104,7 +104,7 @@
  * type: The type of `input`.
  */
 @Operator(group = "linalg.sparse")
-public final class SparseMatrixSparseCholesky extends PrimitiveOp implements Operand<TType> {
+public final class SparseMatrixSparseCholesky extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixSparseCholesky operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixSparseMatMul.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixSparseMatMul.java
index 8de4bc8782f..ba2d0f175f5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixSparseMatMul.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixSparseMatMul.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -105,7 +105,7 @@
  * adjoint_b: If True, `b` adjointed before multiplication.
  */
 @Operator(group = "linalg.sparse")
-public final class SparseMatrixSparseMatMul extends PrimitiveOp implements Operand<TType> {
+public final class SparseMatrixSparseMatMul extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.sparse.SparseMatrixSparseMatMul}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixTranspose.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixTranspose.java
index 3d7a7d459f1..42e75dea97e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixTranspose.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixTranspose.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * conjugates its values.
  */
 @Operator(group = "linalg.sparse")
-public final class SparseMatrixTranspose extends PrimitiveOp implements Operand<TType> {
+public final class SparseMatrixTranspose extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.sparse.SparseMatrixTranspose}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixZeros.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixZeros.java
index 09d21c7a548..0ef578d31f9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixZeros.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseMatrixZeros.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * Creates an all-zeros CSRSparseMatrix with shape `dense_shape`.
  */
 @Operator(group = "linalg.sparse")
-public final class SparseMatrixZeros extends PrimitiveOp implements Operand<TType> {
+public final class SparseMatrixZeros extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixZeros operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseTensorToCSRSparseMatrix.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseTensorToCSRSparseMatrix.java
index a8496e99898..69af2004b6f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseTensorToCSRSparseMatrix.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/sparse/SparseTensorToCSRSparseMatrix.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * Converts a SparseTensor to a (possibly batched) CSRSparseMatrix.
  */
 @Operator(group = "linalg.sparse")
-public final class SparseTensorToCSRSparseMatrix extends PrimitiveOp implements Operand<TType> {
+public final class SparseTensorToCSRSparseMatrix extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SparseTensorToCSRSparseMatrix operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Abs.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Abs.java
index e4ed6bae727..a04d249dc74 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Abs.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Abs.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Abs<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Abs<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Abs operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/AccumulateN.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/AccumulateN.java
index 4045750b9d9..a9ccd3cdf01 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/AccumulateN.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/AccumulateN.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code sum()} output
  */
 @Operator(group = "math")
-public final class AccumulateN<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class AccumulateN<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new AccumulateN operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Acos.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Acos.java
index f48f7e72091..200fa10daad 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Acos.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Acos.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Acos<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Acos<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Acos operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Acosh.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Acosh.java
index 1c711c2c720..e26f402b14e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Acosh.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Acosh.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Acosh<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Acosh<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Acosh operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Add.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Add.java
index e83128a0c8e..2c3c69e735f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Add.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Add.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Add<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Add<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Add operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/AddN.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/AddN.java
index 642bde6f5a6..aa6abe36421 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/AddN.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/AddN.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code sum()} output
  */
 @Operator(group = "math")
-public final class AddN<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class AddN<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new AddN operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Angle.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Angle.java
index 4ef99422335..08c203e2625 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Angle.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Angle.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -52,7 +52,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class Angle<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class Angle<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Angle operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ApproximateEqual.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ApproximateEqual.java
index 1dcbd4bb5c9..83762aa8117 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ApproximateEqual.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ApproximateEqual.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * Returns the truth value of abs(x-y) < tolerance element-wise.
  */
 @Operator(group = "math")
-public final class ApproximateEqual extends PrimitiveOp implements Operand<TBool> {
+public final class ApproximateEqual extends RawOp implements Operand<TBool> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.math.ApproximateEqual}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ArgMax.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ArgMax.java
index 0afac51f520..9670f62b1a5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ArgMax.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ArgMax.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -49,7 +49,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class ArgMax<V extends TNumber> extends PrimitiveOp implements Operand<V> {
+public final class ArgMax<V extends TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new ArgMax operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ArgMin.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ArgMin.java
index efe10cc8407..00e84ed2dc3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ArgMin.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ArgMin.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -49,7 +49,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class ArgMin<V extends TNumber> extends PrimitiveOp implements Operand<V> {
+public final class ArgMin<V extends TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new ArgMin operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Asin.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Asin.java
index 7374236ed07..7825bb02a6a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Asin.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Asin.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Asin<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Asin<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Asin operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Asinh.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Asinh.java
index 5cfe082f19d..93131b0b597 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Asinh.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Asinh.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Asinh<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Asinh<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Asinh operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Atan.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Atan.java
index 9100b8a763a..d09ac0f625e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Atan.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Atan.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Atan<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Atan<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Atan operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Atan2.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Atan2.java
index d2303ef5e25..d77090da6a1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Atan2.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Atan2.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Atan2<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Atan2<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Atan2 operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Atanh.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Atanh.java
index 1cf7b8e132f..2d8596be938 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Atanh.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Atanh.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Atanh<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Atanh<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Atanh operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/BesselI0e.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/BesselI0e.java
index 0847888df3c..b951b555fc9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/BesselI0e.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/BesselI0e.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class BesselI0e<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class BesselI0e<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BesselI0e operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/BesselI1e.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/BesselI1e.java
index 8a045cac601..9d92b8a4d66 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/BesselI1e.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/BesselI1e.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class BesselI1e<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class BesselI1e<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BesselI1e operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Betainc.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Betainc.java
index 81777cf607c..bf42fa10faf 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Betainc.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Betainc.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Betainc<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Betainc<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Betainc operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Bincount.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Bincount.java
index e78275aad5e..30b96bf1b5d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Bincount.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Bincount.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code bins()} output
  */
 @Operator(group = "math")
-public final class Bincount<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Bincount<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Bincount operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Ceil.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Ceil.java
index 164d5c0fbf2..36bcf7ce417 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Ceil.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Ceil.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Ceil<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Ceil<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Ceil operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/CheckNumerics.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/CheckNumerics.java
index d0956b37431..aec047668e9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/CheckNumerics.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/CheckNumerics.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class CheckNumerics<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class CheckNumerics<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new CheckNumerics operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/CompareAndBitpack.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/CompareAndBitpack.java
index 9150128f00a..a00341d467d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/CompareAndBitpack.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/CompareAndBitpack.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -54,7 +54,7 @@
  * a `uint8` tensor shaped `[s0, s1, ..., s_n / 8]`.
  */
 @Operator(group = "math")
-public final class CompareAndBitpack extends PrimitiveOp implements Operand<TUint8> {
+public final class CompareAndBitpack extends RawOp implements Operand<TUint8> {
   
   /**
    * Factory method to create a class wrapping a new CompareAndBitpack operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ComplexAbs.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ComplexAbs.java
index e62e95da19e..f72854aa5ed 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ComplexAbs.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ComplexAbs.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <U> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class ComplexAbs<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class ComplexAbs<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new ComplexAbs operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Conj.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Conj.java
index fff1ff451ab..c633957aeb2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Conj.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Conj.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -47,7 +47,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class Conj<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Conj<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Conj operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Cos.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Cos.java
index 75b1eaf47ce..8a61ed1db2a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Cos.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Cos.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Cos<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Cos<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Cos operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Cosh.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Cosh.java
index 60ab528765e..20f70fe2f0c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Cosh.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Cosh.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Cosh<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Cosh<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Cosh operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Cumprod.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Cumprod.java
index 427412e9e72..faab91b5bd9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Cumprod.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Cumprod.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "math")
-public final class Cumprod<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Cumprod<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.math.Cumprod}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Cumsum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Cumsum.java
index 6e19e500f59..a1027a8b221 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Cumsum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Cumsum.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "math")
-public final class Cumsum<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Cumsum<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.math.Cumsum}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/CumulativeLogsumexp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/CumulativeLogsumexp.java
index 444814820b7..82b702e4def 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/CumulativeLogsumexp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/CumulativeLogsumexp.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -51,7 +51,7 @@
  * 
  * @param <T> data type for {@code out()} output
  */
-public final class CumulativeLogsumexp<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class CumulativeLogsumexp<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.math.CumulativeLogsumexp}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Digamma.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Digamma.java
index 80398a64660..c217acd7f51 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Digamma.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Digamma.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Digamma<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Digamma<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Digamma operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Div.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Div.java
index feb79d82b00..fb34257a1e8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Div.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Div.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Div<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Div<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Div operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/DivNoNan.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/DivNoNan.java
index d1e5ae5c93b..373dcff32cb 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/DivNoNan.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/DivNoNan.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class DivNoNan<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class DivNoNan<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DivNoNan operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Equal.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Equal.java
index e6cd0974355..971a44984c6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Equal.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Equal.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -45,7 +45,7 @@
  * 
  */
 @Operator(group = "math")
-public final class Equal extends PrimitiveOp implements Operand<TBool> {
+public final class Equal extends RawOp implements Operand<TBool> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.math.Equal}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Erf.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Erf.java
index e088cdc9fb3..2f8e2f8c302 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Erf.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Erf.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Erf<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Erf<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Erf operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Erfc.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Erfc.java
index c4296018101..a1494ae42a7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Erfc.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Erfc.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Erfc<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Erfc<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Erfc operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Exp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Exp.java
index ec6c504b1ef..16e93c8ec2c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Exp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Exp.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -59,7 +59,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Exp<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Exp<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Exp operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Expm1.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Expm1.java
index 7116c9ce92d..6998e3d3fdb 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Expm1.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Expm1.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Expm1<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Expm1<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Expm1 operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Fact.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Fact.java
index af86f5f8fd5..7c8f8af6c95 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Fact.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Fact.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Output a fact about factorials.
  */
 @Operator(group = "math")
-public final class Fact extends PrimitiveOp implements Operand<TString> {
+public final class Fact extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new Fact operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Floor.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Floor.java
index eaa89e75e06..fb1955c2e91 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Floor.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Floor.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Floor<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Floor<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Floor operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/FloorDiv.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/FloorDiv.java
index b4a49e3b9ac..b02797cde81 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/FloorDiv.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/FloorDiv.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class FloorDiv<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class FloorDiv<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new FloorDiv operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/FloorMod.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/FloorMod.java
index ede50c50a10..79881c593bc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/FloorMod.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/FloorMod.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class FloorMod<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class FloorMod<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new FloorMod operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Greater.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Greater.java
index bea61a86c6a..a2aef106674 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Greater.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Greater.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * 
  */
 @Operator(group = "math")
-public final class Greater extends PrimitiveOp implements Operand<TBool> {
+public final class Greater extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new Greater operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/GreaterEqual.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/GreaterEqual.java
index a4482168ae2..6097961d214 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/GreaterEqual.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/GreaterEqual.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * 
  */
 @Operator(group = "math")
-public final class GreaterEqual extends PrimitiveOp implements Operand<TBool> {
+public final class GreaterEqual extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new GreaterEqual operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Igamma.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Igamma.java
index 20162d98f20..e6492c17a8e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Igamma.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Igamma.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -47,7 +47,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Igamma<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Igamma<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Igamma operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/IgammaGradA.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/IgammaGradA.java
index d365531fc0d..90e5b649dc5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/IgammaGradA.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/IgammaGradA.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class IgammaGradA<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class IgammaGradA<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new IgammaGradA operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Igammac.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Igammac.java
index ae0867e11f9..03c9ab28002 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Igammac.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Igammac.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -47,7 +47,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Igammac<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Igammac<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Igammac operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Imag.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Imag.java
index 0de7703d555..dbd5b5b8406 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Imag.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Imag.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class Imag<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class Imag<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Imag operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/InvertPermutation.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/InvertPermutation.java
index 95a2a9bc28b..28d0a80d4ad 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/InvertPermutation.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/InvertPermutation.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -50,7 +50,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class InvertPermutation<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class InvertPermutation<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new InvertPermutation operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/IsFinite.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/IsFinite.java
index 04f3d5c8b89..b8136095909 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/IsFinite.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/IsFinite.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * 
  */
 @Operator(group = "math")
-public final class IsFinite extends PrimitiveOp implements Operand<TBool> {
+public final class IsFinite extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new IsFinite operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/IsInf.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/IsInf.java
index 0fd4159733f..429e8aee411 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/IsInf.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/IsInf.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * 
  */
 @Operator(group = "math")
-public final class IsInf extends PrimitiveOp implements Operand<TBool> {
+public final class IsInf extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new IsInf operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/IsNan.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/IsNan.java
index 9daa818b733..1c480c08336 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/IsNan.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/IsNan.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * 
  */
 @Operator(group = "math")
-public final class IsNan extends PrimitiveOp implements Operand<TBool> {
+public final class IsNan extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new IsNan operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Less.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Less.java
index 214a55e7c33..106040ab8b1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Less.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Less.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * 
  */
 @Operator(group = "math")
-public final class Less extends PrimitiveOp implements Operand<TBool> {
+public final class Less extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new Less operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/LessEqual.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/LessEqual.java
index cd4fbcccfe0..094bd19e36c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/LessEqual.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/LessEqual.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * 
  */
 @Operator(group = "math")
-public final class LessEqual extends PrimitiveOp implements Operand<TBool> {
+public final class LessEqual extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new LessEqual operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Lgamma.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Lgamma.java
index 719b2c84be1..42a5baad397 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Lgamma.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Lgamma.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Lgamma<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Lgamma<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Lgamma operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Log.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Log.java
index 29b7855a9b6..1ee4bc3c6e2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Log.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Log.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Log<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Log<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Log operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Log1p.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Log1p.java
index ac79cfc9e74..407cfa649ad 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Log1p.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Log1p.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Log1p<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Log1p<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Log1p operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/LogicalAnd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/LogicalAnd.java
index 198f6f24c93..410cd28dc9d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/LogicalAnd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/LogicalAnd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
  */
 @Operator(group = "math")
-public final class LogicalAnd extends PrimitiveOp implements Operand<TBool> {
+public final class LogicalAnd extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new LogicalAnd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/LogicalNot.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/LogicalNot.java
index cdef2361463..d159d01f88c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/LogicalNot.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/LogicalNot.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Returns the truth value of NOT x element-wise.
  */
 @Operator(group = "math")
-public final class LogicalNot extends PrimitiveOp implements Operand<TBool> {
+public final class LogicalNot extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new LogicalNot operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/LogicalOr.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/LogicalOr.java
index ee571faa18c..a9f33397ae1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/LogicalOr.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/LogicalOr.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
  */
 @Operator(group = "math")
-public final class LogicalOr extends PrimitiveOp implements Operand<TBool> {
+public final class LogicalOr extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new LogicalOr operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Maximum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Maximum.java
index 6757ad388bb..998e5fbc3bf 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Maximum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Maximum.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Maximum<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Maximum<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Maximum operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Mean.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Mean.java
index 40437d5b001..301ff6b1c31 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Mean.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Mean.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class Mean<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Mean<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.math.Mean}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Minimum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Minimum.java
index 39c98ff7f9a..33f6fe5d7af 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Minimum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Minimum.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Minimum<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Minimum<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Minimum operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Mod.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Mod.java
index 962be27adb4..8cd9b2cd30d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Mod.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Mod.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Mod<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Mod<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Mod operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Mul.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Mul.java
index c159e17a0ce..d4cf53f8540 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Mul.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Mul.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Mul<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Mul<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Mul operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/MulNoNan.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/MulNoNan.java
index d2f106c82b9..157b5d1ead0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/MulNoNan.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/MulNoNan.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class MulNoNan<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class MulNoNan<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new MulNoNan operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Ndtri.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Ndtri.java
index 5c71c9910d0..0330942d8b3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Ndtri.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Ndtri.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Ndtri<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Ndtri<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Ndtri operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Neg.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Neg.java
index a5702ee485e..14a1544cb82 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Neg.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Neg.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Neg<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Neg<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Neg operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/NextAfter.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/NextAfter.java
index c75f589453a..4ac1cde3380 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/NextAfter.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/NextAfter.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class NextAfter<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class NextAfter<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new NextAfter operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/NotEqual.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/NotEqual.java
index 5a493eabb31..647b596f6be 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/NotEqual.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/NotEqual.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
  */
 @Operator(group = "math")
-public final class NotEqual extends PrimitiveOp implements Operand<TBool> {
+public final class NotEqual extends RawOp implements Operand<TBool> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.math.NotEqual}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Polygamma.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Polygamma.java
index f7177ac3980..415b5b51837 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Polygamma.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Polygamma.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Polygamma<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Polygamma<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Polygamma operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/PopulationCount.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/PopulationCount.java
index 72f5a5c2b0b..21b22d86fa5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/PopulationCount.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/PopulationCount.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * 8- or 16-bit inputs and then aggregate the resulting counts.
  */
 @Operator(group = "math")
-public final class PopulationCount extends PrimitiveOp implements Operand<TUint8> {
+public final class PopulationCount extends RawOp implements Operand<TUint8> {
   
   /**
    * Factory method to create a class wrapping a new PopulationCount operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Pow.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Pow.java
index 85f6d375e9c..cd22d351e6e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Pow.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Pow.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Pow<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Pow<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Pow operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/QuantizedAdd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/QuantizedAdd.java
index 9dbe912f833..fd2f5890d47 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/QuantizedAdd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/QuantizedAdd.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <V> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class QuantizedAdd<V extends TType> extends PrimitiveOp {
+public final class QuantizedAdd<V extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedAdd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/QuantizedMul.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/QuantizedMul.java
index 48bd51c2d56..a629145fa62 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/QuantizedMul.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/QuantizedMul.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <V> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class QuantizedMul<V extends TType> extends PrimitiveOp {
+public final class QuantizedMul<V extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedMul operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Real.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Real.java
index ec71d59a180..0b619946e0b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Real.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Real.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class Real<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class Real<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Real operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/RealDiv.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/RealDiv.java
index d7929ec77b2..32dcc8988fc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/RealDiv.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/RealDiv.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class RealDiv<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class RealDiv<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RealDiv operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Reciprocal.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Reciprocal.java
index f1e376aad14..b39118351c5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Reciprocal.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Reciprocal.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Reciprocal<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Reciprocal<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Reciprocal operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ReciprocalGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ReciprocalGrad.java
index 16272b8187f..9d9a1f03723 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ReciprocalGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/ReciprocalGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class ReciprocalGrad<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ReciprocalGrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ReciprocalGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/RequantizationRangePerChannel.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/RequantizationRangePerChannel.java
index e8389e871cd..4eb2021ca17 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/RequantizationRangePerChannel.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/RequantizationRangePerChannel.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
 /**
  * Computes requantization range per channel.
  */
-public final class RequantizationRangePerChannel extends PrimitiveOp {
+public final class RequantizationRangePerChannel extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RequantizationRangePerChannel operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/RequantizePerChannel.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/RequantizePerChannel.java
index 3388c74d1f7..793429b9779 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/RequantizePerChannel.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/RequantizePerChannel.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class RequantizePerChannel<U extends TType> extends PrimitiveOp {
+public final class RequantizePerChannel<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RequantizePerChannel operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Rint.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Rint.java
index 5872e53a893..576508d7d30 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Rint.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Rint.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Rint<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Rint<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Rint operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Round.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Round.java
index ab70b0bb010..dbd546baf23 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Round.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Round.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Round<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Round<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Round operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Rsqrt.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Rsqrt.java
index 10e11da0c09..43a6886684d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Rsqrt.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Rsqrt.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Rsqrt<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Rsqrt<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Rsqrt operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/RsqrtGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/RsqrtGrad.java
index 43ae6bc8cff..df8cdcfb392 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/RsqrtGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/RsqrtGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class RsqrtGrad<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class RsqrtGrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RsqrtGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentMax.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentMax.java
index c6548149854..99c1bda676b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentMax.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentMax.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class SegmentMax<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class SegmentMax<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SegmentMax operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentMean.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentMean.java
index 54136f8172b..263a550e74c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentMean.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentMean.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -58,7 +58,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class SegmentMean<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SegmentMean<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SegmentMean operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentMin.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentMin.java
index 2b3b7255ba5..38a0e75784c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentMin.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentMin.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class SegmentMin<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class SegmentMin<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SegmentMin operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentProd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentProd.java
index bba11931bc7..36592e64f85 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentProd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentProd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class SegmentProd<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SegmentProd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SegmentProd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentSum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentSum.java
index 59260733c9e..54287c045b2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentSum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SegmentSum.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class SegmentSum<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SegmentSum<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SegmentSum operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sigmoid.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sigmoid.java
index 65f7f93a2e3..a12d7061324 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sigmoid.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sigmoid.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Sigmoid<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Sigmoid<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sigmoid operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SigmoidGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SigmoidGrad.java
index 9142a665dc0..c53a0ae603f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SigmoidGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SigmoidGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class SigmoidGrad<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SigmoidGrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SigmoidGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sign.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sign.java
index e747f7ccba2..6591ed77c71 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sign.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sign.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Sign<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Sign<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sign operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sin.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sin.java
index 300d4a41ed1..15ef4b31dd2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sin.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sin.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Sin<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Sin<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sin operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sinh.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sinh.java
index 8f213a30360..8785916850b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sinh.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sinh.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Sinh<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Sinh<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sinh operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Softplus.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Softplus.java
index 553762e500a..a4f3a22ebcd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Softplus.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Softplus.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "math")
-public final class Softplus<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Softplus<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Softplus operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SoftplusGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SoftplusGrad.java
index 85721a50e80..f885abcbdeb 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SoftplusGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SoftplusGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class SoftplusGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class SoftplusGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SoftplusGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sqrt.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sqrt.java
index 6c4220555c2..315173746b2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sqrt.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sqrt.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Sqrt<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Sqrt<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sqrt operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SqrtGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SqrtGrad.java
index 75dd482797f..5ba9497bbdd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SqrtGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SqrtGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class SqrtGrad<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SqrtGrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SqrtGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Square.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Square.java
index 167fd22d709..36fdb6bda9c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Square.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Square.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Square<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Square<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Square operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SquaredDifference.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SquaredDifference.java
index a48b23dc757..c860747add8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SquaredDifference.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SquaredDifference.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class SquaredDifference<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SquaredDifference<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SquaredDifference operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sub.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sub.java
index c193de15086..1489a80202d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sub.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Sub.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Sub<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Sub<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sub operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Tan.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Tan.java
index 5157886464e..1b1ddd50ba5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Tan.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Tan.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Tan<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Tan<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Tan operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Tanh.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Tanh.java
index 9a61dc95db2..f2611083984 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Tanh.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Tanh.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Tanh<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Tanh<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Tanh operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/TanhGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/TanhGrad.java
index b42886f4c37..3ebc6ab598d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/TanhGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/TanhGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class TanhGrad<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TanhGrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TanhGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/TruncateDiv.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/TruncateDiv.java
index 56f24afcd3e..a0a1f6697d1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/TruncateDiv.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/TruncateDiv.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class TruncateDiv<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TruncateDiv<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TruncateDiv operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/TruncateMod.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/TruncateMod.java
index 3912bec8abd..cfa0461f460 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/TruncateMod.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/TruncateMod.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class TruncateMod<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class TruncateMod<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TruncateMod operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/UnsortedSegmentMax.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/UnsortedSegmentMax.java
index 6fcaa06c39a..4c509457c3e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/UnsortedSegmentMax.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/UnsortedSegmentMax.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -65,7 +65,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class UnsortedSegmentMax<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class UnsortedSegmentMax<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new UnsortedSegmentMax operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/UnsortedSegmentMin.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/UnsortedSegmentMin.java
index 4e64cc16dd1..bd12cae09b9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/UnsortedSegmentMin.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/UnsortedSegmentMin.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -59,7 +59,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class UnsortedSegmentMin<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class UnsortedSegmentMin<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new UnsortedSegmentMin operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/UnsortedSegmentProd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/UnsortedSegmentProd.java
index bf2e7ff9521..86f2b588cc0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/UnsortedSegmentProd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/UnsortedSegmentProd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -58,7 +58,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class UnsortedSegmentProd<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class UnsortedSegmentProd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new UnsortedSegmentProd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/UnsortedSegmentSum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/UnsortedSegmentSum.java
index 24e82c9ca48..95868ce64d0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/UnsortedSegmentSum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/UnsortedSegmentSum.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -61,7 +61,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class UnsortedSegmentSum<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class UnsortedSegmentSum<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new UnsortedSegmentSum operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Xdivy.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Xdivy.java
index 36b192ce57f..5372f4b5c11 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Xdivy.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Xdivy.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Xdivy<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Xdivy<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Xdivy operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Xlogy.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Xlogy.java
index ddded71bdfe..6b303403408 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Xlogy.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Xlogy.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Xlogy<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Xlogy<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Xlogy operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Zeta.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Zeta.java
index 777ec0926e4..431921f8e2b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Zeta.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Zeta.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Zeta<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Zeta<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Zeta operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/erfinv.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/erfinv.java
index b497b84501d..385bd855018 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/erfinv.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/erfinv.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class erfinv<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class erfinv<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new erfinv operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/AvgPool.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/AvgPool.java
index ca045be0ee0..de1a858b738 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/AvgPool.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/AvgPool.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class AvgPool<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class AvgPool<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.AvgPool}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/AvgPool3d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/AvgPool3d.java
index afa84459a0b..1700745d1ba 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/AvgPool3d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/AvgPool3d.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class AvgPool3d<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class AvgPool3d<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.AvgPool3d}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/AvgPool3dGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/AvgPool3dGrad.java
index c30c0c52650..9426ff8f682 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/AvgPool3dGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/AvgPool3dGrad.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class AvgPool3dGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class AvgPool3dGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.AvgPool3dGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/AvgPoolGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/AvgPoolGrad.java
index 85bcc11bb06..9389f98ad3b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/AvgPoolGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/AvgPoolGrad.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class AvgPoolGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class AvgPoolGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.AvgPoolGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BatchNormWithGlobalNormalization.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BatchNormWithGlobalNormalization.java
index c21511d36c3..23cc0b463ba 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BatchNormWithGlobalNormalization.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BatchNormWithGlobalNormalization.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code result()} output
  */
 @Operator(group = "nn")
-public final class BatchNormWithGlobalNormalization<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class BatchNormWithGlobalNormalization<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchNormWithGlobalNormalization operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BatchNormWithGlobalNormalizationGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BatchNormWithGlobalNormalizationGrad.java
index 79cd07dbcd9..fe2813b3342 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BatchNormWithGlobalNormalizationGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BatchNormWithGlobalNormalizationGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code dx()} output
  */
 @Operator(group = "nn")
-public final class BatchNormWithGlobalNormalizationGrad<T extends TType> extends PrimitiveOp {
+public final class BatchNormWithGlobalNormalizationGrad<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BatchNormWithGlobalNormalizationGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BiasAdd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BiasAdd.java
index 2218ef046d6..6296f75db61 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BiasAdd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BiasAdd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class BiasAdd<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class BiasAdd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.BiasAdd}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BiasAddGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BiasAddGrad.java
index 14fd15ae8ae..dcc2b537f65 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BiasAddGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BiasAddGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class BiasAddGrad<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class BiasAddGrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.BiasAddGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BlockLSTM.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BlockLSTM.java
index 21d9d080461..1c00e74311f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BlockLSTM.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BlockLSTM.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -56,7 +56,7 @@
  * 
  * @param <T> data type for {@code i()} output
  */
-public final class BlockLSTM<T extends TNumber> extends PrimitiveOp {
+public final class BlockLSTM<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.BlockLSTM}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BlockLSTMGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BlockLSTMGrad.java
index 9c713248a91..e80bea4006d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BlockLSTMGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/BlockLSTMGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * 
  * @param <T> data type for {@code xGrad()} output
  */
-public final class BlockLSTMGrad<T extends TNumber> extends PrimitiveOp {
+public final class BlockLSTMGrad<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BlockLSTMGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/ComputeAccidentalHits.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/ComputeAccidentalHits.java
index ca1bf801ec5..a11bb983ae9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/ComputeAccidentalHits.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/ComputeAccidentalHits.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * making the classifier sure that they are sampled labels.
  */
 @Operator(group = "nn")
-public final class ComputeAccidentalHits extends PrimitiveOp {
+public final class ComputeAccidentalHits extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.ComputeAccidentalHits}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv2d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv2d.java
index eb2d3bb8dc0..632d54c3890 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv2d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv2d.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv2d<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Conv2d<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv2d}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv2dBackpropFilter.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv2dBackpropFilter.java
index 501e874034b..91e147def81 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv2dBackpropFilter.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv2dBackpropFilter.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv2dBackpropFilter<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Conv2dBackpropFilter<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv2dBackpropFilter}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv2dBackpropInput.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv2dBackpropInput.java
index 92e697a4dcd..389ddb0be4e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv2dBackpropInput.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv2dBackpropInput.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv2dBackpropInput<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Conv2dBackpropInput<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv2dBackpropInput}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv3d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv3d.java
index 4d7f0261daa..1e80fdb7f80 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv3d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv3d.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv3d<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Conv3d<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv3d}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv3dBackpropFilter.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv3dBackpropFilter.java
index 1fb1fe9a9de..d6d85797b3f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv3dBackpropFilter.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv3dBackpropFilter.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv3dBackpropFilter<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Conv3dBackpropFilter<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv3dBackpropFilter}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv3dBackpropInput.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv3dBackpropInput.java
index 81bf166cf2c..08e163494bf 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv3dBackpropInput.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Conv3dBackpropInput.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv3dBackpropInput<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class Conv3dBackpropInput<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv3dBackpropInput}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CtcBeamSearchDecoder.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CtcBeamSearchDecoder.java
index 4bf0070d30a..8d212909901 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CtcBeamSearchDecoder.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CtcBeamSearchDecoder.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code logProbability()} output
  */
 @Operator(group = "nn")
-public final class CtcBeamSearchDecoder<T extends TNumber> extends PrimitiveOp {
+public final class CtcBeamSearchDecoder<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CtcBeamSearchDecoder}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CtcGreedyDecoder.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CtcGreedyDecoder.java
index b9fa01f1235..eecea029a34 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CtcGreedyDecoder.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CtcGreedyDecoder.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -46,7 +46,7 @@
  * @param <T> data type for {@code logProbability()} output
  */
 @Operator(group = "nn")
-public final class CtcGreedyDecoder<T extends TNumber> extends PrimitiveOp {
+public final class CtcGreedyDecoder<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CtcGreedyDecoder}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CtcLoss.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CtcLoss.java
index eea6e7cd451..b39f344373e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CtcLoss.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CtcLoss.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code loss()} output
  */
 @Operator(group = "nn")
-public final class CtcLoss<T extends TNumber> extends PrimitiveOp {
+public final class CtcLoss<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CtcLoss}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRNN.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRNN.java
index 5849305be28..9159d1c69c3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRNN.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRNN.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -72,7 +72,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class CudnnRNN<T extends TNumber> extends PrimitiveOp {
+public final class CudnnRNN<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CudnnRNN}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRNNBackprop.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRNNBackprop.java
index 73ff3d0ac1b..adeadb27292 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRNNBackprop.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRNNBackprop.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -82,7 +82,7 @@
  * 
  * @param <T> data type for {@code inputBackprop()} output
  */
-public final class CudnnRNNBackprop<T extends TNumber> extends PrimitiveOp {
+public final class CudnnRNNBackprop<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CudnnRNNBackprop}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRNNCanonicalToParams.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRNNCanonicalToParams.java
index c8ab5c790c1..1b1c51f056a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRNNCanonicalToParams.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRNNCanonicalToParams.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -67,7 +67,7 @@
  * @param <T> data type for {@code params()} output
  */
 @Operator(group = "nn")
-public final class CudnnRNNCanonicalToParams<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class CudnnRNNCanonicalToParams<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CudnnRNNCanonicalToParams}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRNNParamsToCanonical.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRNNParamsToCanonical.java
index 4b5a03cb1fd..2db3c22e373 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRNNParamsToCanonical.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRNNParamsToCanonical.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -68,7 +68,7 @@
  * @param <T> data type for {@code weights()} output
  */
 @Operator(group = "nn")
-public final class CudnnRNNParamsToCanonical<T extends TNumber> extends PrimitiveOp {
+public final class CudnnRNNParamsToCanonical<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CudnnRNNParamsToCanonical}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRnnParamsSize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRnnParamsSize.java
index 3010b2c0585..6cff6fe9836 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRnnParamsSize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CudnnRnnParamsSize.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -58,7 +58,7 @@
  * @param <U> data type for {@code paramsSize()} output
  */
 @Operator(group = "nn")
-public final class CudnnRnnParamsSize<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class CudnnRnnParamsSize<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CudnnRnnParamsSize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DataFormatDimMap.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DataFormatDimMap.java
index 172da091178..eb82df7184c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DataFormatDimMap.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DataFormatDimMap.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "nn")
-public final class DataFormatDimMap<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class DataFormatDimMap<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DataFormatDimMap}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DataFormatVecPermute.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DataFormatVecPermute.java
index d9e5de17191..5a04c0847c7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DataFormatVecPermute.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DataFormatVecPermute.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "nn")
-public final class DataFormatVecPermute<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class DataFormatVecPermute<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DataFormatVecPermute}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DepthToSpace.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DepthToSpace.java
index 991ee3d0d98..523977a1db0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DepthToSpace.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DepthToSpace.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -113,7 +113,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class DepthToSpace<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class DepthToSpace<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DepthToSpace}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DepthwiseConv2dNative.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DepthwiseConv2dNative.java
index 9def862bd69..36277e498d5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DepthwiseConv2dNative.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DepthwiseConv2dNative.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -52,7 +52,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class DepthwiseConv2dNative<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class DepthwiseConv2dNative<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DepthwiseConv2dNative}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DepthwiseConv2dNativeBackpropFilter.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DepthwiseConv2dNativeBackpropFilter.java
index e44e9b867b8..074d37aba9b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DepthwiseConv2dNativeBackpropFilter.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DepthwiseConv2dNativeBackpropFilter.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class DepthwiseConv2dNativeBackpropFilter<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class DepthwiseConv2dNativeBackpropFilter<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DepthwiseConv2dNativeBackpropFilter}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DepthwiseConv2dNativeBackpropInput.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DepthwiseConv2dNativeBackpropInput.java
index c76ec88de9a..323890cbc1e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DepthwiseConv2dNativeBackpropInput.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/DepthwiseConv2dNativeBackpropInput.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class DepthwiseConv2dNativeBackpropInput<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class DepthwiseConv2dNativeBackpropInput<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DepthwiseConv2dNativeBackpropInput}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Dilation2d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Dilation2d.java
index ccabb1feff4..984c4621881 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Dilation2d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Dilation2d.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -59,7 +59,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Dilation2d<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Dilation2d<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Dilation2d operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Dilation2dBackpropFilter.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Dilation2dBackpropFilter.java
index e280fbad821..1e413d9a08c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Dilation2dBackpropFilter.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Dilation2dBackpropFilter.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code filterBackprop()} output
  */
 @Operator(group = "nn")
-public final class Dilation2dBackpropFilter<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Dilation2dBackpropFilter<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Dilation2dBackpropFilter operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Dilation2dBackpropInput.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Dilation2dBackpropInput.java
index b4428bc5e85..7d247c4288b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Dilation2dBackpropInput.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Dilation2dBackpropInput.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code inBackprop()} output
  */
 @Operator(group = "nn")
-public final class Dilation2dBackpropInput<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Dilation2dBackpropInput<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Dilation2dBackpropInput operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Elu.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Elu.java
index 3215a879a37..f138ee46ce3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Elu.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Elu.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class Elu<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Elu<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Elu operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/EluGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/EluGrad.java
index 4e702e2fa07..fd41f261813 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/EluGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/EluGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class EluGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class EluGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new EluGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FixedUnigramCandidateSampler.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FixedUnigramCandidateSampler.java
index 3a9598e303d..e99a41a2c56 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FixedUnigramCandidateSampler.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FixedUnigramCandidateSampler.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * true labels.
  */
 @Operator(group = "nn")
-public final class FixedUnigramCandidateSampler extends PrimitiveOp {
+public final class FixedUnigramCandidateSampler extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FixedUnigramCandidateSampler}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FractionalAvgPool.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FractionalAvgPool.java
index 0896f663f42..189f1b9c27c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FractionalAvgPool.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FractionalAvgPool.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class FractionalAvgPool<T extends TNumber> extends PrimitiveOp {
+public final class FractionalAvgPool<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FractionalAvgPool}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FractionalAvgPoolGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FractionalAvgPoolGrad.java
index 16aae6b7211..26c06215c54 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FractionalAvgPoolGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FractionalAvgPoolGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class FractionalAvgPoolGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class FractionalAvgPoolGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FractionalAvgPoolGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FractionalMaxPool.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FractionalMaxPool.java
index a8b96976cb5..015b99a14eb 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FractionalMaxPool.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FractionalMaxPool.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -65,7 +65,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class FractionalMaxPool<T extends TNumber> extends PrimitiveOp {
+public final class FractionalMaxPool<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FractionalMaxPool}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FractionalMaxPoolGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FractionalMaxPoolGrad.java
index e04211f58b5..cabbf2e038a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FractionalMaxPoolGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FractionalMaxPoolGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class FractionalMaxPoolGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class FractionalMaxPoolGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FractionalMaxPoolGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FusedBatchNorm.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FusedBatchNorm.java
index 5e56c8f3316..c3940dc9378 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FusedBatchNorm.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FusedBatchNorm.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <U> data type for {@code batchMean()} output
  */
 @Operator(group = "nn")
-public final class FusedBatchNorm<T extends TNumber, U extends TNumber> extends PrimitiveOp {
+public final class FusedBatchNorm<T extends TNumber, U extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FusedBatchNorm}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FusedBatchNormGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FusedBatchNormGrad.java
index 4d50bc51b15..52bd5e98084 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FusedBatchNormGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FusedBatchNormGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <U> data type for {@code scaleBackprop()} output
  */
 @Operator(group = "nn")
-public final class FusedBatchNormGrad<T extends TNumber, U extends TNumber> extends PrimitiveOp {
+public final class FusedBatchNormGrad<T extends TNumber, U extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FusedBatchNormGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FusedPadConv2d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FusedPadConv2d.java
index a5abfcf0f88..11ec154a076 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FusedPadConv2d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FusedPadConv2d.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class FusedPadConv2d<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class FusedPadConv2d<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new FusedPadConv2d operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FusedResizeAndPadConv2d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FusedResizeAndPadConv2d.java
index b49a4e9628b..4eda6e97eaa 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FusedResizeAndPadConv2d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/FusedResizeAndPadConv2d.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -47,7 +47,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class FusedResizeAndPadConv2d<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class FusedResizeAndPadConv2d<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FusedResizeAndPadConv2d}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/GRUBlockCell.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/GRUBlockCell.java
index 7c1460abcef..49c7d619410 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/GRUBlockCell.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/GRUBlockCell.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -78,7 +78,7 @@
  * 
  * @param <T> data type for {@code r()} output
  */
-public final class GRUBlockCell<T extends TNumber> extends PrimitiveOp {
+public final class GRUBlockCell<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new GRUBlockCell operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/GRUBlockCellGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/GRUBlockCellGrad.java
index 5f87c5406db..bea3442c6c9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/GRUBlockCellGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/GRUBlockCellGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -114,7 +114,7 @@
  * 
  * @param <T> data type for {@code dX()} output
  */
-public final class GRUBlockCellGrad<T extends TNumber> extends PrimitiveOp {
+public final class GRUBlockCellGrad<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new GRUBlockCellGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/InTopK.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/InTopK.java
index 605d3c3172f..1255067ed44 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/InTopK.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/InTopK.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -49,7 +49,7 @@
  * $$out_i = predictions_{i, targets_i} \in TopKIncludingTies(predictions_i)$$
  */
 @Operator(group = "nn")
-public final class InTopK extends PrimitiveOp implements Operand<TBool> {
+public final class InTopK extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new InTopK operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/InvGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/InvGrad.java
index 9dd6bb0257d..b0df0c43ee0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/InvGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/InvGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class InvGrad<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class InvGrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new InvGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/L2Loss.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/L2Loss.java
index dce23f52cb3..91d141c787c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/L2Loss.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/L2Loss.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class L2Loss<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class L2Loss<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new L2Loss operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LSTMBlockCell.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LSTMBlockCell.java
index b13605b3ee7..a10d335bc0b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LSTMBlockCell.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LSTMBlockCell.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -58,7 +58,7 @@
  * 
  * @param <T> data type for {@code i()} output
  */
-public final class LSTMBlockCell<T extends TNumber> extends PrimitiveOp {
+public final class LSTMBlockCell<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.LSTMBlockCell}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LSTMBlockCellGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LSTMBlockCellGrad.java
index 7d1e3c9f65a..bfb5dae0118 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LSTMBlockCellGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LSTMBlockCellGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code csPrevGrad()} output
  */
-public final class LSTMBlockCellGrad<T extends TNumber> extends PrimitiveOp {
+public final class LSTMBlockCellGrad<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new LSTMBlockCellGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LeakyRelu.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LeakyRelu.java
index 2635a069d7b..54579426b78 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LeakyRelu.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LeakyRelu.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * 
  * @param <T> data type for {@code activations()} output
  */
-public final class LeakyRelu<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class LeakyRelu<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.LeakyRelu}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LearnedUnigramCandidateSampler.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LearnedUnigramCandidateSampler.java
index b529eb01749..017ee428cde 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LearnedUnigramCandidateSampler.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LearnedUnigramCandidateSampler.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * true labels.
  */
 @Operator(group = "nn")
-public final class LearnedUnigramCandidateSampler extends PrimitiveOp {
+public final class LearnedUnigramCandidateSampler extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.LearnedUnigramCandidateSampler}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LocalResponseNormalization.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LocalResponseNormalization.java
index 4963cada497..0004fed685b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LocalResponseNormalization.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LocalResponseNormalization.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -46,7 +46,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class LocalResponseNormalization<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class LocalResponseNormalization<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.LocalResponseNormalization}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LocalResponseNormalizationGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LocalResponseNormalizationGrad.java
index b07de0f4e77..24d769e571a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LocalResponseNormalizationGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LocalResponseNormalizationGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class LocalResponseNormalizationGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class LocalResponseNormalizationGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.LocalResponseNormalizationGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LogSoftmax.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LogSoftmax.java
index 199705a8be5..58035248560 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LogSoftmax.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/LogSoftmax.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code logsoftmax()} output
  */
 @Operator(group = "nn")
-public final class LogSoftmax<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class LogSoftmax<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new LogSoftmax operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPool.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPool.java
index 21e28bbcc12..4df68034706 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPool.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPool.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPool<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class MaxPool<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPool}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPool3d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPool3d.java
index 7715f2d4c67..c38fd7b341e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPool3d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPool3d.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPool3d<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class MaxPool3d<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPool3d}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPool3dGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPool3dGrad.java
index 1d93b9099d1..8361c38b80a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPool3dGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPool3dGrad.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPool3dGrad<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class MaxPool3dGrad<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPool3dGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPool3dGradGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPool3dGradGrad.java
index 867a1bcf55e..93407692efa 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPool3dGradGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPool3dGradGrad.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPool3dGradGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class MaxPool3dGradGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPool3dGradGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolGrad.java
index 44fb23d5eeb..7db3693e736 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPoolGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class MaxPoolGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPoolGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolGradGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolGradGrad.java
index c4929fd761a..9fee7af4c0e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolGradGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolGradGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPoolGradGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class MaxPoolGradGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPoolGradGrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolGradGradWithArgmax.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolGradGradWithArgmax.java
index 81d5845004d..232f2ec18a8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolGradGradWithArgmax.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolGradGradWithArgmax.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPoolGradGradWithArgmax<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class MaxPoolGradGradWithArgmax<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPoolGradGradWithArgmax}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolGradWithArgmax.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolGradWithArgmax.java
index 642f4b4dcac..8d1aa1da798 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolGradWithArgmax.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolGradWithArgmax.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class MaxPoolGradWithArgmax<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class MaxPoolGradWithArgmax<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPoolGradWithArgmax}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolWithArgmax.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolWithArgmax.java
index da2d201df13..4eeb66cbc68 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolWithArgmax.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/MaxPoolWithArgmax.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * @param <U> data type for {@code argmax()} output
  */
 @Operator(group = "nn")
-public final class MaxPoolWithArgmax<T extends TNumber, U extends TNumber> extends PrimitiveOp {
+public final class MaxPoolWithArgmax<T extends TNumber, U extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPoolWithArgmax}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/NthElement.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/NthElement.java
index f57162c9786..cf379fa5ecf 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/NthElement.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/NthElement.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code values()} output
  */
 @Operator(group = "nn")
-public final class NthElement<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class NthElement<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.NthElement}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedAvgPool.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedAvgPool.java
index f7bc0e93ca2..9ac24133f7c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedAvgPool.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedAvgPool.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class QuantizedAvgPool<T extends TType> extends PrimitiveOp {
+public final class QuantizedAvgPool<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedAvgPool operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedBatchNormWithGlobalNormalization.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedBatchNormWithGlobalNormalization.java
index 7f64e90996f..dd5b716b401 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedBatchNormWithGlobalNormalization.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedBatchNormWithGlobalNormalization.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <U> data type for {@code result()} output
  */
 @Operator(group = "nn")
-public final class QuantizedBatchNormWithGlobalNormalization<U extends TType> extends PrimitiveOp {
+public final class QuantizedBatchNormWithGlobalNormalization<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedBatchNormWithGlobalNormalization operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedBiasAdd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedBiasAdd.java
index 088f798fd58..818c4455ac5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedBiasAdd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedBiasAdd.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class QuantizedBiasAdd<V extends TType> extends PrimitiveOp {
+public final class QuantizedBiasAdd<V extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedBiasAdd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DAndRelu.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DAndRelu.java
index c2648ee23bf..f1258c3ac71 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DAndRelu.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DAndRelu.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DAndRelu<V extends TType> extends PrimitiveOp {
+public final class QuantizedConv2DAndRelu<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DAndRelu}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DAndReluAndRequantize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DAndReluAndRequantize.java
index e50b24a0b58..9a763e629d9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DAndReluAndRequantize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DAndReluAndRequantize.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DAndReluAndRequantize<V extends TType> extends PrimitiveOp {
+public final class QuantizedConv2DAndReluAndRequantize<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DAndReluAndRequantize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DAndRequantize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DAndRequantize.java
index 64eb64ec954..ac1ca66f079 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DAndRequantize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DAndRequantize.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DAndRequantize<V extends TType> extends PrimitiveOp {
+public final class QuantizedConv2DAndRequantize<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DAndRequantize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DPerChannel.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DPerChannel.java
index aa849605efd..da2dfa6e491 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DPerChannel.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DPerChannel.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DPerChannel<V extends TType> extends PrimitiveOp {
+public final class QuantizedConv2DPerChannel<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DPerChannel}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBias.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBias.java
index 437e7bee3db..da843bf735a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBias.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBias.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBias<V extends TType> extends PrimitiveOp {
+public final class QuantizedConv2DWithBias<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBias}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasAndRelu.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasAndRelu.java
index 9f3eff62e0c..6176626745d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasAndRelu.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasAndRelu.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasAndRelu<V extends TType> extends PrimitiveOp {
+public final class QuantizedConv2DWithBiasAndRelu<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasAndRelu}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasAndReluAndRequantize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasAndReluAndRequantize.java
index bd4c1622a85..d6700e175a5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasAndReluAndRequantize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasAndReluAndRequantize.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * @param <W> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasAndReluAndRequantize<W extends TType> extends PrimitiveOp {
+public final class QuantizedConv2DWithBiasAndReluAndRequantize<W extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasAndReluAndRequantize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasAndRequantize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasAndRequantize.java
index 678dc1ffdaf..7f8d24095e4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasAndRequantize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasAndRequantize.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * @param <W> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasAndRequantize<W extends TType> extends PrimitiveOp {
+public final class QuantizedConv2DWithBiasAndRequantize<W extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasAndRequantize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasSignedSumAndReluAndRequantize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasSignedSumAndReluAndRequantize.java
index 83ddbad856e..cc3d6cc73dc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasSignedSumAndReluAndRequantize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasSignedSumAndReluAndRequantize.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * @param <X> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasSignedSumAndReluAndRequantize<X extends TType> extends PrimitiveOp {
+public final class QuantizedConv2DWithBiasSignedSumAndReluAndRequantize<X extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasSignedSumAndReluAndRequantize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasSumAndRelu.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasSumAndRelu.java
index fb3bfbaef23..69759e0bc8a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasSumAndRelu.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasSumAndRelu.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasSumAndRelu<V extends TType> extends PrimitiveOp {
+public final class QuantizedConv2DWithBiasSumAndRelu<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasSumAndRelu}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasSumAndReluAndRequantize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasSumAndReluAndRequantize.java
index 163cd0b7841..e6d03b99188 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasSumAndReluAndRequantize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2DWithBiasSumAndReluAndRequantize.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * @param <X> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasSumAndReluAndRequantize<X extends TType> extends PrimitiveOp {
+public final class QuantizedConv2DWithBiasSumAndReluAndRequantize<X extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasSumAndReluAndRequantize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2d.java
index c08f4a71462..c791a624c51 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedConv2d.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class QuantizedConv2d<V extends TType> extends PrimitiveOp {
+public final class QuantizedConv2d<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2d}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedDepthwiseConv2D.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedDepthwiseConv2D.java
index 4cb6c024488..2145de9c8eb 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedDepthwiseConv2D.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedDepthwiseConv2D.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedDepthwiseConv2D<V extends TType> extends PrimitiveOp {
+public final class QuantizedDepthwiseConv2D<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedDepthwiseConv2D}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedDepthwiseConv2DWithBias.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedDepthwiseConv2DWithBias.java
index de255097264..5aa0d466d0e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedDepthwiseConv2DWithBias.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedDepthwiseConv2DWithBias.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedDepthwiseConv2DWithBias<V extends TType> extends PrimitiveOp {
+public final class QuantizedDepthwiseConv2DWithBias<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedDepthwiseConv2DWithBias}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedDepthwiseConv2DWithBiasAndRelu.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedDepthwiseConv2DWithBiasAndRelu.java
index d95b883d624..c7d755f9594 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedDepthwiseConv2DWithBiasAndRelu.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedDepthwiseConv2DWithBiasAndRelu.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedDepthwiseConv2DWithBiasAndRelu<V extends TType> extends PrimitiveOp {
+public final class QuantizedDepthwiseConv2DWithBiasAndRelu<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedDepthwiseConv2DWithBiasAndRelu}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize.java
index feedc1dca07..dd5844cee3a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <W> data type for {@code output()} output
  */
-public final class QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize<W extends TType> extends PrimitiveOp {
+public final class QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize<W extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedInstanceNorm.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedInstanceNorm.java
index 114d9f2efbf..ba393889984 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedInstanceNorm.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedInstanceNorm.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "nn")
-public final class QuantizedInstanceNorm<T extends TType> extends PrimitiveOp {
+public final class QuantizedInstanceNorm<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedInstanceNorm}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedMaxPool.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedMaxPool.java
index bac2e80e343..94c00253cc5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedMaxPool.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedMaxPool.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class QuantizedMaxPool<T extends TType> extends PrimitiveOp {
+public final class QuantizedMaxPool<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedMaxPool operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedRelu.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedRelu.java
index c9ededee354..9c9407e0b9a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedRelu.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedRelu.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <U> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class QuantizedRelu<U extends TType> extends PrimitiveOp {
+public final class QuantizedRelu<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedRelu operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedRelu6.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedRelu6.java
index d14c6d5e91e..150ec50779e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedRelu6.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedRelu6.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <U> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class QuantizedRelu6<U extends TType> extends PrimitiveOp {
+public final class QuantizedRelu6<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedRelu6 operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedReluX.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedReluX.java
index 85eddefe122..2d446c3a45d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedReluX.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/QuantizedReluX.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <U> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class QuantizedReluX<U extends TType> extends PrimitiveOp {
+public final class QuantizedReluX<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedReluX operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Relu.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Relu.java
index 22a36003c31..2facaa697ec 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Relu.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Relu.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class Relu<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Relu<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Relu operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Relu6.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Relu6.java
index 50b8b3d7cf1..f32eb410f00 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Relu6.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Relu6.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class Relu6<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Relu6<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Relu6 operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Relu6Grad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Relu6Grad.java
index f1235315baa..7cd8e3197e6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Relu6Grad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Relu6Grad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class Relu6Grad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Relu6Grad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Relu6Grad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/ReluGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/ReluGrad.java
index 477dd3552b9..c467c606b69 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/ReluGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/ReluGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class ReluGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class ReluGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ReluGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Selu.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Selu.java
index dc9e02d1081..dae469aa5a3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Selu.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Selu.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class Selu<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Selu<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Selu operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SeluGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SeluGrad.java
index 4eb44c64c5f..91389503235 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SeluGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SeluGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class SeluGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class SeluGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SeluGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Softmax.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Softmax.java
index f62b0d1eebc..c1744627645 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Softmax.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Softmax.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code softmax()} output
  */
 @Operator(group = "nn")
-public final class Softmax<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Softmax<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Softmax operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SoftmaxCrossEntropyWithLogits.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SoftmaxCrossEntropyWithLogits.java
index 9a5c5ae6715..41281b996ff 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SoftmaxCrossEntropyWithLogits.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SoftmaxCrossEntropyWithLogits.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code loss()} output
  */
 @Operator(group = "nn")
-public final class SoftmaxCrossEntropyWithLogits<T extends TNumber> extends PrimitiveOp {
+public final class SoftmaxCrossEntropyWithLogits<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SoftmaxCrossEntropyWithLogits operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Softsign.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Softsign.java
index dc0f54d81e8..e117be94537 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Softsign.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/Softsign.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class Softsign<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class Softsign<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Softsign operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SoftsignGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SoftsignGrad.java
index 820eb220405..2c4fd467661 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SoftsignGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SoftsignGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class SoftsignGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class SoftsignGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SoftsignGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SpaceToBatch.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SpaceToBatch.java
index 481a0d7e64d..b8ab8d48658 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SpaceToBatch.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SpaceToBatch.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class SpaceToBatch<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SpaceToBatch<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SpaceToBatch operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SpaceToDepth.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SpaceToDepth.java
index ccd9073475d..100ac91e7da 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SpaceToDepth.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SpaceToDepth.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -107,7 +107,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class SpaceToDepth<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SpaceToDepth<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.SpaceToDepth}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SparseSoftmaxCrossEntropyWithLogits.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SparseSoftmaxCrossEntropyWithLogits.java
index fff7c68b1eb..f2434cd4eb8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SparseSoftmaxCrossEntropyWithLogits.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SparseSoftmaxCrossEntropyWithLogits.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code loss()} output
  */
 @Operator(group = "nn")
-public final class SparseSoftmaxCrossEntropyWithLogits<T extends TNumber> extends PrimitiveOp {
+public final class SparseSoftmaxCrossEntropyWithLogits<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseSoftmaxCrossEntropyWithLogits operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/TopK.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/TopK.java
index b2787a02146..28a810ebc54 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/TopK.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/TopK.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -46,7 +46,7 @@
  * @param <T> data type for {@code values()} output
  */
 @Operator(group = "nn")
-public final class TopK<T extends TNumber> extends PrimitiveOp {
+public final class TopK<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.TopK}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/Dequantize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/Dequantize.java
index 2637a8c2412..aaf1fdee6b3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/Dequantize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/Dequantize.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -81,7 +81,7 @@
  * 
  */
 @Operator(group = "quantization")
-public final class Dequantize extends PrimitiveOp implements Operand<TFloat32> {
+public final class Dequantize extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.Dequantize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxArgs.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxArgs.java
index bd2806204ed..16ea096ef9d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxArgs.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxArgs.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * Quantization is called fake since the output is still in floating point.
  */
 @Operator(group = "quantization")
-public final class FakeQuantWithMinMaxArgs extends PrimitiveOp implements Operand<TFloat32> {
+public final class FakeQuantWithMinMaxArgs extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.FakeQuantWithMinMaxArgs}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxArgsGradient.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxArgsGradient.java
index 6c2224cdbe1..71da232b5df 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxArgsGradient.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxArgsGradient.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Compute gradients for a FakeQuantWithMinMaxArgs operation.
  */
 @Operator(group = "quantization")
-public final class FakeQuantWithMinMaxArgsGradient extends PrimitiveOp implements Operand<TFloat32> {
+public final class FakeQuantWithMinMaxArgsGradient extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.FakeQuantWithMinMaxArgsGradient}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxVars.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxVars.java
index 7c522a38a66..21113c6a6f3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxVars.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxVars.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -51,7 +51,7 @@
  * values.
  */
 @Operator(group = "quantization")
-public final class FakeQuantWithMinMaxVars extends PrimitiveOp implements Operand<TFloat32> {
+public final class FakeQuantWithMinMaxVars extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.FakeQuantWithMinMaxVars}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxVarsGradient.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxVarsGradient.java
index a22ac08cd69..7b4e10d9c21 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxVarsGradient.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxVarsGradient.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Compute gradients for a FakeQuantWithMinMaxVars operation.
  */
 @Operator(group = "quantization")
-public final class FakeQuantWithMinMaxVarsGradient extends PrimitiveOp {
+public final class FakeQuantWithMinMaxVarsGradient extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.FakeQuantWithMinMaxVarsGradient}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxVarsPerChannel.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxVarsPerChannel.java
index 43af7a8e6db..1302ae47b32 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxVarsPerChannel.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxVarsPerChannel.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -52,7 +52,7 @@
  * values.
  */
 @Operator(group = "quantization")
-public final class FakeQuantWithMinMaxVarsPerChannel extends PrimitiveOp implements Operand<TFloat32> {
+public final class FakeQuantWithMinMaxVarsPerChannel extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.FakeQuantWithMinMaxVarsPerChannel}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxVarsPerChannelGradient.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxVarsPerChannelGradient.java
index 867846f0a93..3e104c42c90 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxVarsPerChannelGradient.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/FakeQuantWithMinMaxVarsPerChannelGradient.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Compute gradients for a FakeQuantWithMinMaxVarsPerChannel operation.
  */
 @Operator(group = "quantization")
-public final class FakeQuantWithMinMaxVarsPerChannelGradient extends PrimitiveOp {
+public final class FakeQuantWithMinMaxVarsPerChannelGradient extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.FakeQuantWithMinMaxVarsPerChannelGradient}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/Quantize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/Quantize.java
index bc589d79a68..1b6ed2fd791 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/Quantize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/Quantize.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -145,7 +145,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "quantization")
-public final class Quantize<T extends TType> extends PrimitiveOp {
+public final class Quantize<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.Quantize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizeAndDequantize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizeAndDequantize.java
index b8939522fdd..d90d91706d9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizeAndDequantize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizeAndDequantize.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "quantization")
-public final class QuantizeAndDequantize<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class QuantizeAndDequantize<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.QuantizeAndDequantize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizeDownAndShrinkRange.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizeDownAndShrinkRange.java
index 5044f3af747..3b77c20f70c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizeDownAndShrinkRange.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizeDownAndShrinkRange.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -58,7 +58,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "quantization")
-public final class QuantizeDownAndShrinkRange<U extends TType> extends PrimitiveOp {
+public final class QuantizeDownAndShrinkRange<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizeDownAndShrinkRange operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedConcat.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedConcat.java
index bf0d5ae5685..46f73857d91 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedConcat.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedConcat.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "quantization")
-public final class QuantizedConcat<T extends TType> extends PrimitiveOp {
+public final class QuantizedConcat<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedConcat operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/RequantizationRange.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/RequantizationRange.java
index 06a5e78fecd..85eddcd506a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/RequantizationRange.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/RequantizationRange.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * `Requantize`.
  */
 @Operator(group = "quantization")
-public final class RequantizationRange extends PrimitiveOp {
+public final class RequantizationRange extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RequantizationRange operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/Requantize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/Requantize.java
index 358b82d267d..987dd660095 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/Requantize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/Requantize.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "quantization")
-public final class Requantize<U extends TType> extends PrimitiveOp {
+public final class Requantize<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new Requantize operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedGather.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedGather.java
index aa6d8a307d6..c200b82da2a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedGather.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedGather.java
@@ -24,7 +24,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -65,7 +65,7 @@
  * @param <T> data type for {@code outputNestedSplits()} output
  * @param <U> data type for {@code outputDenseValues()} output
  */
-public final class RaggedGather<T extends TNumber, U extends TType> extends PrimitiveOp {
+public final class RaggedGather<T extends TNumber, U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RaggedGather operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedRange.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedRange.java
index 8e3183215cb..8fd3fb45bea 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedRange.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedRange.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -51,7 +51,7 @@
  * @param <U> data type for {@code rtNestedSplits()} output
  * @param <T> data type for {@code rtDenseValues()} output
  */
-public final class RaggedRange<U extends TNumber, T extends TNumber> extends PrimitiveOp {
+public final class RaggedRange<U extends TNumber, T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RaggedRange operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedTensorFromVariant.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedTensorFromVariant.java
index 5166f7228c1..3b094d70e0b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedTensorFromVariant.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedTensorFromVariant.java
@@ -24,7 +24,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -51,7 +51,7 @@
  * @param <U> data type for {@code outputNestedSplits()} output
  * @param <T> data type for {@code outputDenseValues()} output
  */
-public final class RaggedTensorFromVariant<U extends TNumber, T extends TType> extends PrimitiveOp {
+public final class RaggedTensorFromVariant<U extends TNumber, T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RaggedTensorFromVariant operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedTensorToSparse.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedTensorToSparse.java
index 07f02e5d441..d4443b915ac 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedTensorToSparse.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedTensorToSparse.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * 
  * @param <U> data type for {@code sparseValues()} output
  */
-public final class RaggedTensorToSparse<U extends TType> extends PrimitiveOp {
+public final class RaggedTensorToSparse<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RaggedTensorToSparse operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedTensorToTensor.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedTensorToTensor.java
index 111b3d38f5c..d5b03b37352 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedTensorToTensor.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedTensorToTensor.java
@@ -23,7 +23,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -58,7 +58,7 @@
  * 
  * @param <U> data type for {@code result()} output
  */
-public final class RaggedTensorToTensor<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class RaggedTensorToTensor<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new RaggedTensorToTensor operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedTensorToVariant.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedTensorToVariant.java
index 9f08df23863..b8c1570a573 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedTensorToVariant.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/ragged/RaggedTensorToVariant.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -45,7 +45,7 @@
  * corresponding decoding logic.
  * 
  */
-public final class RaggedTensorToVariant extends PrimitiveOp implements Operand<TType> {
+public final class RaggedTensorToVariant extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new RaggedTensorToVariant operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/AllCandidateSampler.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/AllCandidateSampler.java
index 6f4707dcafe..1fca347c024 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/AllCandidateSampler.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/AllCandidateSampler.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * true labels.
  */
 @Operator(group = "random")
-public final class AllCandidateSampler extends PrimitiveOp {
+public final class AllCandidateSampler extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.AllCandidateSampler}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/AnonymousRandomSeedGenerator.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/AnonymousRandomSeedGenerator.java
index 9af0142654c..f0d6d9d77cd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/AnonymousRandomSeedGenerator.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/AnonymousRandomSeedGenerator.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
 
 /**
  */
-public final class AnonymousRandomSeedGenerator extends PrimitiveOp {
+public final class AnonymousRandomSeedGenerator extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new AnonymousRandomSeedGenerator operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/DeleteRandomSeedGenerator.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/DeleteRandomSeedGenerator.java
index cdffdf03ef7..63e2698983b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/DeleteRandomSeedGenerator.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/DeleteRandomSeedGenerator.java
@@ -20,14 +20,14 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 
 /**
  */
-public final class DeleteRandomSeedGenerator extends PrimitiveOp {
+public final class DeleteRandomSeedGenerator extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new DeleteRandomSeedGenerator operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/LogUniformCandidateSampler.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/LogUniformCandidateSampler.java
index 00ef5030f4c..8295f36e678 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/LogUniformCandidateSampler.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/LogUniformCandidateSampler.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * true labels.
  */
 @Operator(group = "random")
-public final class LogUniformCandidateSampler extends PrimitiveOp {
+public final class LogUniformCandidateSampler extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.LogUniformCandidateSampler}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/Multinomial.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/Multinomial.java
index 38478009416..41fb03d9dc2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/Multinomial.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/Multinomial.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class Multinomial<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class Multinomial<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.Multinomial}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/NonDeterministicInts.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/NonDeterministicInts.java
index c0388176616..b251813e265 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/NonDeterministicInts.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/NonDeterministicInts.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class NonDeterministicInts<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class NonDeterministicInts<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new NonDeterministicInts operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/ParameterizedTruncatedNormal.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/ParameterizedTruncatedNormal.java
index 9735aa16935..8ed64aa14a7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/ParameterizedTruncatedNormal.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/ParameterizedTruncatedNormal.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class ParameterizedTruncatedNormal<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class ParameterizedTruncatedNormal<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.ParameterizedTruncatedNormal}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomGamma.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomGamma.java
index d6bcc58740c..65ae0fbcbb4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomGamma.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomGamma.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomGamma<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class RandomGamma<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomGamma}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomGammaGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomGammaGrad.java
index f7372890cdd..ba25e19b24e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomGammaGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomGammaGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class RandomGammaGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class RandomGammaGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RandomGammaGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomPoisson.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomPoisson.java
index ed922f18b0b..e7bcb3d6855 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomPoisson.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomPoisson.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -46,7 +46,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomPoisson<V extends TNumber> extends PrimitiveOp implements Operand<V> {
+public final class RandomPoisson<V extends TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomPoisson}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomShuffle.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomShuffle.java
index eb5f1b06196..738d92b7f0e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomShuffle.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomShuffle.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomShuffle<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class RandomShuffle<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomShuffle}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomStandardNormal.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomStandardNormal.java
index e4d0f54f8cd..48e08f355b3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomStandardNormal.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomStandardNormal.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomStandardNormal<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class RandomStandardNormal<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomStandardNormal}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomUniform.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomUniform.java
index 17264b6cc70..121a58533c1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomUniform.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomUniform.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomUniform<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class RandomUniform<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomUniform}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomUniformInt.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomUniformInt.java
index da9f381e0a2..b2eafcadf4b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomUniformInt.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RandomUniformInt.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomUniformInt<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class RandomUniformInt<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomUniformInt}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RecordInput.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RecordInput.java
index a711a2f6f04..a8520fc1144 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RecordInput.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RecordInput.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Emits randomized records.
  */
 @Operator(group = "random")
-public final class RecordInput extends PrimitiveOp implements Operand<TString> {
+public final class RecordInput extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RecordInput}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RngSkip.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RngSkip.java
index 565ccaf5235..11c45bbeb2a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RngSkip.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/RngSkip.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * (or any other distribution). The actual increment added to the
  * counter is an unspecified implementation detail.  
  */
-public final class RngSkip extends PrimitiveOp {
+public final class RngSkip extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RngSkip operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulRandomBinomial.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulRandomBinomial.java
index 90282b53b58..f6b9ed59a68 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulRandomBinomial.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulRandomBinomial.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatefulRandomBinomial<V extends TNumber> extends PrimitiveOp implements Operand<V> {
+public final class StatefulRandomBinomial<V extends TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new StatefulRandomBinomial operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulStandardNormal.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulStandardNormal.java
index 424308b5d5c..fd0f1cd16a4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulStandardNormal.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulStandardNormal.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatefulStandardNormal<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class StatefulStandardNormal<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new StatefulStandardNormal operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulTruncatedNormal.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulTruncatedNormal.java
index 8fafcb1d3ea..97ad2eb4f00 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulTruncatedNormal.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulTruncatedNormal.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class StatefulTruncatedNormal<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class StatefulTruncatedNormal<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new StatefulTruncatedNormal operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulUniform.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulUniform.java
index 5811ba3f284..8c6d86dd507 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulUniform.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulUniform.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class StatefulUniform<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class StatefulUniform<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new StatefulUniform operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulUniformFullInt.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulUniformFullInt.java
index 2d6136487d3..b5dc3921dd8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulUniformFullInt.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulUniformFullInt.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class StatefulUniformFullInt<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class StatefulUniformFullInt<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new StatefulUniformFullInt operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulUniformInt.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulUniformInt.java
index 4dc0814cfa6..a5550877593 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulUniformInt.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatefulUniformInt.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class StatefulUniformInt<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class StatefulUniformInt<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new StatefulUniformInt operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessMultinomial.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessMultinomial.java
index 7eaf05dd424..d5473395eb3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessMultinomial.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessMultinomial.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatelessMultinomial<V extends TNumber> extends PrimitiveOp implements Operand<V> {
+public final class StatelessMultinomial<V extends TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new StatelessMultinomial operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomNormal.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomNormal.java
index 642cd9bf334..028537a3417 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomNormal.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomNormal.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatelessRandomNormal<V extends TNumber> extends PrimitiveOp implements Operand<V> {
+public final class StatelessRandomNormal<V extends TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new StatelessRandomNormal operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomUniform.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomUniform.java
index 688799fc381..5ea49ccf36d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomUniform.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomUniform.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatelessRandomUniform<V extends TNumber> extends PrimitiveOp implements Operand<V> {
+public final class StatelessRandomUniform<V extends TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new StatelessRandomUniform operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomUniformInt.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomUniformInt.java
index 444fc8c853d..ebb569ea222 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomUniformInt.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomUniformInt.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class StatelessRandomUniformInt<V extends TNumber> extends PrimitiveOp implements Operand<V> {
+public final class StatelessRandomUniformInt<V extends TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new StatelessRandomUniformInt operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessTruncatedNormal.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessTruncatedNormal.java
index 9e0cfda629d..180e5ffa4b5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessTruncatedNormal.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessTruncatedNormal.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatelessTruncatedNormal<V extends TNumber> extends PrimitiveOp implements Operand<V> {
+public final class StatelessTruncatedNormal<V extends TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new StatelessTruncatedNormal operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/TruncatedNormal.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/TruncatedNormal.java
index b3c887b1f1c..b40ddfb6e47 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/TruncatedNormal.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/TruncatedNormal.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class TruncatedNormal<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class TruncatedNormal<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.TruncatedNormal}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/UniformCandidateSampler.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/UniformCandidateSampler.java
index 0c9aee0cc1f..e568dd965ba 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/UniformCandidateSampler.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/UniformCandidateSampler.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * true labels.
  */
 @Operator(group = "random")
-public final class UniformCandidateSampler extends PrimitiveOp {
+public final class UniformCandidateSampler extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.UniformCandidateSampler}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchFft.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchFft.java
index cce8aaabcd4..029a9990900 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchFft.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchFft.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  */
 @Operator(group = "signal")
-public final class BatchFft extends PrimitiveOp implements Operand<TType> {
+public final class BatchFft extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new BatchFft operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchFft2d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchFft2d.java
index 125e7750e4b..c8357878666 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchFft2d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchFft2d.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  */
 @Operator(group = "signal")
-public final class BatchFft2d extends PrimitiveOp implements Operand<TType> {
+public final class BatchFft2d extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new BatchFft2d operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchFft3d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchFft3d.java
index 3ba9694ddad..4ad58e855ae 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchFft3d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchFft3d.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  */
 @Operator(group = "signal")
-public final class BatchFft3d extends PrimitiveOp implements Operand<TType> {
+public final class BatchFft3d extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new BatchFft3d operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchIfft.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchIfft.java
index 641cde58e4d..0e098f94b72 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchIfft.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchIfft.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  */
 @Operator(group = "signal")
-public final class BatchIfft extends PrimitiveOp implements Operand<TType> {
+public final class BatchIfft extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new BatchIfft operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchIfft2d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchIfft2d.java
index fd1a2ea5492..e689c9061d4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchIfft2d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchIfft2d.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  */
 @Operator(group = "signal")
-public final class BatchIfft2d extends PrimitiveOp implements Operand<TType> {
+public final class BatchIfft2d extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new BatchIfft2d operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchIfft3d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchIfft3d.java
index 9d9e651154c..5f23ed1ca7a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchIfft3d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/BatchIfft3d.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  */
 @Operator(group = "signal")
-public final class BatchIfft3d extends PrimitiveOp implements Operand<TType> {
+public final class BatchIfft3d extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new BatchIfft3d operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Fft.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Fft.java
index 2f00347534d..802788288a6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Fft.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Fft.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Fft<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Fft<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Fft operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Fft2d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Fft2d.java
index 9fd5dc788d2..aaafdb8392f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Fft2d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Fft2d.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Fft2d<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Fft2d<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Fft2d operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Fft3d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Fft3d.java
index e99a148c248..a7b29547d0c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Fft3d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Fft3d.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Fft3d<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Fft3d<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Fft3d operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Ifft.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Ifft.java
index cfb5c55a679..6ba09167aa0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Ifft.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Ifft.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Ifft<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Ifft<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Ifft operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Ifft2d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Ifft2d.java
index 0d44d12eb29..086dd9d2338 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Ifft2d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Ifft2d.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Ifft2d<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Ifft2d<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Ifft2d operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Ifft3d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Ifft3d.java
index 0425437229f..d1d114fc2d5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Ifft3d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Ifft3d.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Ifft3d<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Ifft3d<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Ifft3d operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Irfft.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Irfft.java
index 1bd546d83ce..8cbeb80aec5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Irfft.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Irfft.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -51,7 +51,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Irfft<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class Irfft<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Irfft operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Irfft2d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Irfft2d.java
index 5f88c1420b9..a383b340c45 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Irfft2d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Irfft2d.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -52,7 +52,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Irfft2d<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class Irfft2d<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Irfft2d operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Irfft3d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Irfft3d.java
index 3287a858a67..278bf3eac13 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Irfft3d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Irfft3d.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -52,7 +52,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Irfft3d<U extends TNumber> extends PrimitiveOp implements Operand<U> {
+public final class Irfft3d<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Irfft3d operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Rfft.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Rfft.java
index 49bfc0f9009..5b3dc8a4199 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Rfft.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Rfft.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -47,7 +47,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Rfft<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class Rfft<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Rfft operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Rfft2d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Rfft2d.java
index 7b68e0acead..7f47b98f969 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Rfft2d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Rfft2d.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Rfft2d<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class Rfft2d<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Rfft2d operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Rfft3d.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Rfft3d.java
index f1d0f69f633..7fa5f8f23b7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Rfft3d.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/signal/Rfft3d.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Rfft3d<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class Rfft3d<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Rfft3d operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/AddManySparseToTensorsMap.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/AddManySparseToTensorsMap.java
index 227eb7e4424..f3b4e77d1f3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/AddManySparseToTensorsMap.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/AddManySparseToTensorsMap.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -54,7 +54,7 @@
  * `TakeManySparseFromTensorsMap`.  Ensure the Operations are colocated.
  */
 @Operator(group = "sparse")
-public final class AddManySparseToTensorsMap extends PrimitiveOp implements Operand<TInt64> {
+public final class AddManySparseToTensorsMap extends RawOp implements Operand<TInt64> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.AddManySparseToTensorsMap}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/AddSparseToTensorsMap.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/AddSparseToTensorsMap.java
index 747691da44c..0cc79427ce1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/AddSparseToTensorsMap.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/AddSparseToTensorsMap.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -47,7 +47,7 @@
  * `TakeManySparseFromTensorsMap`.  Ensure the Operations are colocated.
  */
 @Operator(group = "sparse")
-public final class AddSparseToTensorsMap extends PrimitiveOp implements Operand<TInt64> {
+public final class AddSparseToTensorsMap extends RawOp implements Operand<TInt64> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.AddSparseToTensorsMap}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/DenseToDenseSetOperation.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/DenseToDenseSetOperation.java
index e175b9f4600..7308a8a8ecb 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/DenseToDenseSetOperation.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/DenseToDenseSetOperation.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code resultValues()} output
  */
 @Operator(group = "sparse")
-public final class DenseToDenseSetOperation<T extends TType> extends PrimitiveOp {
+public final class DenseToDenseSetOperation<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.DenseToDenseSetOperation}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/DenseToSparseSetOperation.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/DenseToSparseSetOperation.java
index 1941fe6b63a..85a490c25a0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/DenseToSparseSetOperation.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/DenseToSparseSetOperation.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -50,7 +50,7 @@
  * @param <T> data type for {@code resultValues()} output
  */
 @Operator(group = "sparse")
-public final class DenseToSparseSetOperation<T extends TType> extends PrimitiveOp {
+public final class DenseToSparseSetOperation<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.DenseToSparseSetOperation}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/DeserializeSparse.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/DeserializeSparse.java
index 1e0744bb3eb..a4fb2ee2e39 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/DeserializeSparse.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/DeserializeSparse.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -77,7 +77,7 @@
  * @param <U> data type for {@code sparseValues()} output
  */
 @Operator(group = "sparse")
-public final class DeserializeSparse<U extends TType> extends PrimitiveOp {
+public final class DeserializeSparse<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new DeserializeSparse operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseAccumulatorApplyGradient.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseAccumulatorApplyGradient.java
index 5cf7cbbebed..15751d4ca97 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseAccumulatorApplyGradient.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseAccumulatorApplyGradient.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * global_step.
  */
 @Operator(group = "sparse")
-public final class SparseAccumulatorApplyGradient extends PrimitiveOp {
+public final class SparseAccumulatorApplyGradient extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseAccumulatorApplyGradient operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseAccumulatorTakeGradient.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseAccumulatorTakeGradient.java
index a8046267c21..d072e331bbf 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseAccumulatorTakeGradient.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseAccumulatorTakeGradient.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code values()} output
  */
 @Operator(group = "sparse")
-public final class SparseAccumulatorTakeGradient<T extends TType> extends PrimitiveOp {
+public final class SparseAccumulatorTakeGradient<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseAccumulatorTakeGradient operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseAdd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseAdd.java
index 532b539f2d5..1bab6a714a0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseAdd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseAdd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code sumValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseAdd<T extends TType> extends PrimitiveOp {
+public final class SparseAdd<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseAdd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseAddGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseAddGrad.java
index 6bee019c568..1709c008119 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseAddGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseAddGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code aValGrad()} output
  */
 @Operator(group = "sparse")
-public final class SparseAddGrad<T extends TType> extends PrimitiveOp {
+public final class SparseAddGrad<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseAddGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseConcat.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseConcat.java
index fe31317f6b9..1ee35437c40 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseConcat.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseConcat.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -77,7 +77,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseConcat<T extends TType> extends PrimitiveOp {
+public final class SparseConcat<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseConcat operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseConditionalAccumulator.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseConditionalAccumulator.java
index c9aaf0e13a6..92fbad600a1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseConditionalAccumulator.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseConditionalAccumulator.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * the accumulator.
  */
 @Operator(group = "sparse")
-public final class SparseConditionalAccumulator extends PrimitiveOp implements Operand<TString> {
+public final class SparseConditionalAccumulator extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseConditionalAccumulator}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseCross.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseCross.java
index c46a837c917..72d7107e2d5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseCross.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseCross.java
@@ -23,7 +23,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -73,7 +73,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseCross<T extends TType> extends PrimitiveOp {
+public final class SparseCross<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseCross operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseDenseCwiseAdd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseDenseCwiseAdd.java
index 8ec609fb8e3..aace49ffa77 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseDenseCwiseAdd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseDenseCwiseAdd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseDenseCwiseAdd<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SparseDenseCwiseAdd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseDenseCwiseAdd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseDenseCwiseDiv.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseDenseCwiseDiv.java
index d6a90c13123..78e4bcfe8b4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseDenseCwiseDiv.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseDenseCwiseDiv.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseDenseCwiseDiv<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SparseDenseCwiseDiv<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseDenseCwiseDiv operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseDenseCwiseMul.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseDenseCwiseMul.java
index 63024323e52..78b37a2306a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseDenseCwiseMul.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseDenseCwiseMul.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseDenseCwiseMul<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SparseDenseCwiseMul<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseDenseCwiseMul operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseFillEmptyRows.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseFillEmptyRows.java
index 58f4d3a083f..47baf154e30 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseFillEmptyRows.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseFillEmptyRows.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -72,7 +72,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseFillEmptyRows<T extends TType> extends PrimitiveOp {
+public final class SparseFillEmptyRows<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseFillEmptyRows operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseFillEmptyRowsGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseFillEmptyRowsGrad.java
index cc6c80c22e3..7289cfa1eef 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseFillEmptyRowsGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseFillEmptyRowsGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code dValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseFillEmptyRowsGrad<T extends TType> extends PrimitiveOp {
+public final class SparseFillEmptyRowsGrad<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseFillEmptyRowsGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseMatMul.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseMatMul.java
index 6fcd5c97f94..42922e892cd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseMatMul.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseMatMul.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * in the input gradient when that gradient comes from a Relu.
  */
 @Operator(group = "sparse")
-public final class SparseMatMul extends PrimitiveOp implements Operand<TFloat32> {
+public final class SparseMatMul extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseMatMul}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReduceMax.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReduceMax.java
index 847ed6cdcbf..9e8ffaf3484 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReduceMax.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReduceMax.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseReduceMax<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class SparseReduceMax<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseReduceMax}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReduceMaxSparse.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReduceMaxSparse.java
index 4fa8eee1123..de96c4d2105 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReduceMaxSparse.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReduceMaxSparse.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseReduceMaxSparse<T extends TNumber> extends PrimitiveOp {
+public final class SparseReduceMaxSparse<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseReduceMaxSparse}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReduceSum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReduceSum.java
index ab3ff676b37..b072fb46bfd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReduceSum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReduceSum.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseReduceSum<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SparseReduceSum<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseReduceSum}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReduceSumSparse.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReduceSumSparse.java
index 6aab676e7e9..befdc901b28 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReduceSumSparse.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReduceSumSparse.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseReduceSumSparse<T extends TType> extends PrimitiveOp {
+public final class SparseReduceSumSparse<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseReduceSumSparse}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReorder.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReorder.java
index 846b363355d..88be4106deb 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReorder.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReorder.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseReorder<T extends TType> extends PrimitiveOp {
+public final class SparseReorder<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseReorder operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReshape.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReshape.java
index cd98994686f..7d2799f8ffe 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReshape.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseReshape.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -47,7 +47,7 @@
  * `output_shape` has length `R_out`.
  */
 @Operator(group = "sparse")
-public final class SparseReshape extends PrimitiveOp {
+public final class SparseReshape extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseReshape operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentMean.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentMean.java
index 46ba16e27de..785b1149b0a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentMean.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentMean.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentMean<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class SparseSegmentMean<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSegmentMean operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentMeanGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentMeanGrad.java
index 31be141dc15..a0c8e8b8e43 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentMeanGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentMeanGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentMeanGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class SparseSegmentMeanGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSegmentMeanGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentMeanWithNumSegments.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentMeanWithNumSegments.java
index dd716de9b96..0458eca8621 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentMeanWithNumSegments.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentMeanWithNumSegments.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentMeanWithNumSegments<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class SparseSegmentMeanWithNumSegments<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSegmentMeanWithNumSegments operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSqrtN.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSqrtN.java
index 1652ea46f89..03b6e015a80 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSqrtN.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSqrtN.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentSqrtN<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class SparseSegmentSqrtN<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSegmentSqrtN operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSqrtNGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSqrtNGrad.java
index 944620e493c..cbe39991793 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSqrtNGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSqrtNGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentSqrtNGrad<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class SparseSegmentSqrtNGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSegmentSqrtNGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSqrtNWithNumSegments.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSqrtNWithNumSegments.java
index 987e383404c..ce787acb499 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSqrtNWithNumSegments.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSqrtNWithNumSegments.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentSqrtNWithNumSegments<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class SparseSegmentSqrtNWithNumSegments<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSegmentSqrtNWithNumSegments operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSum.java
index 8cfff4d74e6..16e47ab2431 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSum.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -65,7 +65,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentSum<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class SparseSegmentSum<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSegmentSum operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSumWithNumSegments.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSumWithNumSegments.java
index ad5a2ad505c..569d0c691c6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSumWithNumSegments.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSegmentSumWithNumSegments.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -63,7 +63,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentSumWithNumSegments<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class SparseSegmentSumWithNumSegments<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSegmentSumWithNumSegments operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSlice.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSlice.java
index ad3a282e34e..5c429a40d9a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSlice.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSlice.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -50,7 +50,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseSlice<T extends TType> extends PrimitiveOp {
+public final class SparseSlice<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseSlice operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSliceGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSliceGrad.java
index 8d6a2499198..172d8bd5816 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSliceGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSliceGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code valGrad()} output
  */
 @Operator(group = "sparse")
-public final class SparseSliceGrad<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SparseSliceGrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSliceGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSoftmax.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSoftmax.java
index f6c6b743f73..ee37d13c818 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSoftmax.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSoftmax.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -51,7 +51,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSoftmax<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class SparseSoftmax<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSoftmax operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSparseMaximum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSparseMaximum.java
index 3171d6fd994..d6d86234578 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSparseMaximum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSparseMaximum.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseSparseMaximum<T extends TNumber> extends PrimitiveOp {
+public final class SparseSparseMaximum<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseSparseMaximum operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSparseMinimum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSparseMinimum.java
index ebb4bd4981d..f46065ae9fc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSparseMinimum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSparseMinimum.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseSparseMinimum<T extends TType> extends PrimitiveOp {
+public final class SparseSparseMinimum<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseSparseMinimum operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSplit.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSplit.java
index 1e96243f95e..dee18e0e862 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSplit.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseSplit.java
@@ -23,7 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -54,7 +54,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseSplit<T extends TType> extends PrimitiveOp {
+public final class SparseSplit<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseSplit operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseTensorDenseAdd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseTensorDenseAdd.java
index 0142638fa69..86f9d3394d1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseTensorDenseAdd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseTensorDenseAdd.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseTensorDenseAdd<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class SparseTensorDenseAdd<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new SparseTensorDenseAdd operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseTensorDenseMatMul.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseTensorDenseMatMul.java
index d80511f000f..858bce58f73 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseTensorDenseMatMul.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseTensorDenseMatMul.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -45,7 +45,7 @@
  * @param <U> data type for {@code product()} output
  */
 @Operator(group = "sparse")
-public final class SparseTensorDenseMatMul<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class SparseTensorDenseMatMul<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseTensorDenseMatMul}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseToDense.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseToDense.java
index 39a75a4174e..04b21e5d46e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseToDense.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseToDense.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -52,7 +52,7 @@
  * @param <U> data type for {@code dense()} output
  */
 @Operator(group = "sparse")
-public final class SparseToDense<U extends TType> extends PrimitiveOp implements Operand<U> {
+public final class SparseToDense<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseToDense}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseToSparseSetOperation.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseToSparseSetOperation.java
index 79628e6b8bf..3b606bbd6e9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseToSparseSetOperation.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/SparseToSparseSetOperation.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -58,7 +58,7 @@
  * @param <T> data type for {@code resultValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseToSparseSetOperation<T extends TType> extends PrimitiveOp {
+public final class SparseToSparseSetOperation<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseToSparseSetOperation}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/TakeManySparseFromTensorsMap.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/TakeManySparseFromTensorsMap.java
index cb312fbf56c..8b38ac4f936 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/TakeManySparseFromTensorsMap.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/sparse/TakeManySparseFromTensorsMap.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -80,7 +80,7 @@
  * @param <T> data type for {@code sparseValues()} output
  */
 @Operator(group = "sparse")
-public final class TakeManySparseFromTensorsMap<T extends TType> extends PrimitiveOp {
+public final class TakeManySparseFromTensorsMap<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.TakeManySparseFromTensorsMap}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Join.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Join.java
index 0470f138037..87306bd9239 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Join.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Join.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * with the given separator (default is an empty separator).
  */
 @Operator(group = "strings")
-public final class Join extends PrimitiveOp implements Operand<TString> {
+public final class Join extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.Join}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Lower.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Lower.java
index a2a4a5a3f19..7f32962685e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Lower.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Lower.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  */
 @Operator(group = "strings")
-public final class Lower extends PrimitiveOp implements Operand<TString> {
+public final class Lower extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.Lower}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ReduceJoin.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ReduceJoin.java
index a8ae8b758f0..615262737c6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ReduceJoin.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ReduceJoin.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -56,7 +56,7 @@
  * 
  */
 @Operator(group = "strings")
-public final class ReduceJoin extends PrimitiveOp implements Operand<TString> {
+public final class ReduceJoin extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.ReduceJoin}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/RegexFullMatch.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/RegexFullMatch.java
index 7386dd9a054..bb03576fd0d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/RegexFullMatch.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/RegexFullMatch.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * The pattern follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
  */
 @Operator(group = "strings")
-public final class RegexFullMatch extends PrimitiveOp implements Operand<TBool> {
+public final class RegexFullMatch extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new RegexFullMatch operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/RegexReplace.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/RegexReplace.java
index cd5d156738e..39d76d9115b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/RegexReplace.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/RegexReplace.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * It follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
  */
 @Operator(group = "strings")
-public final class RegexReplace extends PrimitiveOp implements Operand<TString> {
+public final class RegexReplace extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.RegexReplace}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StaticRegexFullMatch.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StaticRegexFullMatch.java
index 21f9fc5f5dd..fe6714ca733 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StaticRegexFullMatch.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StaticRegexFullMatch.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * <p>
  * The pattern follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
  */
-public final class StaticRegexFullMatch extends PrimitiveOp implements Operand<TBool> {
+public final class StaticRegexFullMatch extends RawOp implements Operand<TBool> {
   
   /**
    * Factory method to create a class wrapping a new StaticRegexFullMatch operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StaticRegexReplace.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StaticRegexReplace.java
index c9e42f0f14c..e09c93144d4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StaticRegexReplace.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StaticRegexReplace.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * <p>
  * It follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
  */
-public final class StaticRegexReplace extends PrimitiveOp implements Operand<TString> {
+public final class StaticRegexReplace extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.StaticRegexReplace}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StringFormat.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StringFormat.java
index bd33f99191e..0e6798c4bf4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StringFormat.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StringFormat.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * Formats a string template using a list of tensors, pretty-printing tensor summaries.
  */
 @Operator(group = "strings")
-public final class StringFormat extends PrimitiveOp implements Operand<TString> {
+public final class StringFormat extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.StringFormat}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StringLength.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StringLength.java
index 7fb77aab791..421e16555d1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StringLength.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StringLength.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * Computes the length of each string given in the input tensor.
  */
 @Operator(group = "strings")
-public final class StringLength extends PrimitiveOp implements Operand<TInt32> {
+public final class StringLength extends RawOp implements Operand<TInt32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.StringLength}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StringNGrams.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StringNGrams.java
index 64ec3e284cf..e54a46a6b69 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StringNGrams.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StringNGrams.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code ngramsSplits()} output
  */
 @Operator(group = "strings")
-public final class StringNGrams<T extends TNumber> extends PrimitiveOp {
+public final class StringNGrams<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new StringNGrams operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StringSplit.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StringSplit.java
index 093b57763d7..d1e4b45d745 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StringSplit.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/StringSplit.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -56,7 +56,7 @@
  * Note that the above mentioned behavior matches python's str.split.
  */
 @Operator(group = "strings")
-public final class StringSplit extends PrimitiveOp {
+public final class StringSplit extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.StringSplit}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Strip.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Strip.java
index a2d724507f7..9c1d8f39b41 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Strip.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Strip.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Strip leading and trailing whitespaces from the Tensor.
  */
 @Operator(group = "strings")
-public final class Strip extends PrimitiveOp implements Operand<TString> {
+public final class Strip extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new Strip operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Substr.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Substr.java
index 5f3bff8475d..725344f3eea 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Substr.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Substr.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -103,7 +103,7 @@
  * 
  */
 @Operator(group = "strings")
-public final class Substr extends PrimitiveOp implements Operand<TString> {
+public final class Substr extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.Substr}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ToHashBucket.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ToHashBucket.java
index 2d74409e4ff..82d26aebe40 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ToHashBucket.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ToHashBucket.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * `tf.string_to_hash_bucket_fast()` or `tf.string_to_hash_bucket_strong()`.
  */
 @Operator(group = "strings")
-public final class ToHashBucket extends PrimitiveOp implements Operand<TInt64> {
+public final class ToHashBucket extends RawOp implements Operand<TInt64> {
   
   /**
    * Factory method to create a class wrapping a new ToHashBucket operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ToHashBucketFast.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ToHashBucketFast.java
index 1b2f79e3ded..e8483cf0c6c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ToHashBucketFast.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ToHashBucketFast.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * `tf.string_to_hash_bucket_strong`.
  */
 @Operator(group = "strings")
-public final class ToHashBucketFast extends PrimitiveOp implements Operand<TInt64> {
+public final class ToHashBucketFast extends RawOp implements Operand<TInt64> {
   
   /**
    * Factory method to create a class wrapping a new ToHashBucketFast operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ToHashBucketStrong.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ToHashBucketStrong.java
index fdd22d327d0..fdb57ca8238 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ToHashBucketStrong.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ToHashBucketStrong.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -47,7 +47,7 @@
  * time than `tf.string_to_hash_bucket_fast`.
  */
 @Operator(group = "strings")
-public final class ToHashBucketStrong extends PrimitiveOp implements Operand<TInt64> {
+public final class ToHashBucketStrong extends RawOp implements Operand<TInt64> {
   
   /**
    * Factory method to create a class wrapping a new ToHashBucketStrong operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ToNumber.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ToNumber.java
index 38028ed87cd..7b22dd5673d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ToNumber.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/ToNumber.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "strings")
-public final class ToNumber<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class ToNumber<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ToNumber operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeDecode.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeDecode.java
index b665d0d26fc..1d5f077d04b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeDecode.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeDecode.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -54,7 +54,7 @@
  * 
  * @param <T> data type for {@code rowSplits()} output
  */
-public final class UnicodeDecode<T extends TNumber> extends PrimitiveOp {
+public final class UnicodeDecode<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.UnicodeDecode}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeDecodeWithOffsets.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeDecodeWithOffsets.java
index 62923b32480..019afa8fe33 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeDecodeWithOffsets.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeDecodeWithOffsets.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -60,7 +60,7 @@
  * 
  * @param <T> data type for {@code rowSplits()} output
  */
-public final class UnicodeDecodeWithOffsets<T extends TNumber> extends PrimitiveOp {
+public final class UnicodeDecodeWithOffsets<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.UnicodeDecodeWithOffsets}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeEncode.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeEncode.java
index 8a818ed77de..1a539366d81 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeEncode.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeEncode.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -49,7 +49,7 @@
  * }</pre>
  * 
  */
-public final class UnicodeEncode extends PrimitiveOp implements Operand<TString> {
+public final class UnicodeEncode extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.UnicodeEncode}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeScript.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeScript.java
index 3094892b27d..92b93e1a9fd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeScript.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeScript.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * match input shape.
  */
 @Operator(group = "strings")
-public final class UnicodeScript extends PrimitiveOp implements Operand<TInt32> {
+public final class UnicodeScript extends RawOp implements Operand<TInt32> {
   
   /**
    * Factory method to create a class wrapping a new UnicodeScript operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeTranscode.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeTranscode.java
index 4a04af8e028..a1e4ba33314 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeTranscode.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnicodeTranscode.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -56,7 +56,7 @@
  * but as metadata, and so is not preserved in the output.
  */
 @Operator(group = "strings")
-public final class UnicodeTranscode extends PrimitiveOp implements Operand<TString> {
+public final class UnicodeTranscode extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.UnicodeTranscode}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnsortedSegmentJoin.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnsortedSegmentJoin.java
index 2a843e8d374..47043fac5b2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnsortedSegmentJoin.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/UnsortedSegmentJoin.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -60,7 +60,7 @@
  * 
  */
 @Operator(group = "strings")
-public final class UnsortedSegmentJoin extends PrimitiveOp implements Operand<TString> {
+public final class UnsortedSegmentJoin extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.UnsortedSegmentJoin}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Upper.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Upper.java
index 9b60175c440..26647ba792c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Upper.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/strings/Upper.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  */
 @Operator(group = "strings")
-public final class Upper extends PrimitiveOp implements Operand<TString> {
+public final class Upper extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.Upper}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/AudioSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/AudioSummary.java
index 23d31336e17..f8382c2cede 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/AudioSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/AudioSummary.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -47,7 +47,7 @@
  *    generated sequentially as '<i>tag</i>/audio/0', '<i>tag</i>/audio/1', etc.
  */
 @Operator(group = "summary")
-public final class AudioSummary extends PrimitiveOp implements Operand<TString> {
+public final class AudioSummary extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.summary.AudioSummary}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/CloseSummaryWriter.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/CloseSummaryWriter.java
index ff7330f7d2c..c056b2f4f35 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/CloseSummaryWriter.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/CloseSummaryWriter.java
@@ -20,14 +20,14 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 
 /**
  */
-public final class CloseSummaryWriter extends PrimitiveOp {
+public final class CloseSummaryWriter extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new CloseSummaryWriter operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/CreateSummaryDbWriter.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/CreateSummaryDbWriter.java
index bcb09c78753..50cfefb2e9f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/CreateSummaryDbWriter.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/CreateSummaryDbWriter.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -28,7 +28,7 @@
 
 /**
  */
-public final class CreateSummaryDbWriter extends PrimitiveOp {
+public final class CreateSummaryDbWriter extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new CreateSummaryDbWriter operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/CreateSummaryFileWriter.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/CreateSummaryFileWriter.java
index a9ba9e9939b..13130955bca 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/CreateSummaryFileWriter.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/CreateSummaryFileWriter.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
 
 /**
  */
-public final class CreateSummaryFileWriter extends PrimitiveOp {
+public final class CreateSummaryFileWriter extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new CreateSummaryFileWriter operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/FlushSummaryWriter.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/FlushSummaryWriter.java
index 3122fb962aa..16babb3df73 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/FlushSummaryWriter.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/FlushSummaryWriter.java
@@ -20,14 +20,14 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 
 /**
  */
-public final class FlushSummaryWriter extends PrimitiveOp {
+public final class FlushSummaryWriter extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new FlushSummaryWriter operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/HistogramSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/HistogramSummary.java
index e49aee577f6..c98efad5b3b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/HistogramSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/HistogramSummary.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * This op reports an `InvalidArgument` error if any value is not finite.
  */
 @Operator(group = "summary")
-public final class HistogramSummary extends PrimitiveOp implements Operand<TString> {
+public final class HistogramSummary extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new HistogramSummary operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/ImageSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/ImageSummary.java
index 91257e11745..50cc52f5769 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/ImageSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/ImageSummary.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.Tensor;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -81,7 +81,7 @@
  * red.
  */
 @Operator(group = "summary")
-public final class ImageSummary extends PrimitiveOp implements Operand<TString> {
+public final class ImageSummary extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.summary.ImageSummary}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/ImportEvent.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/ImportEvent.java
index 6c608e8e129..736aa827d82 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/ImportEvent.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/ImportEvent.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -28,7 +28,7 @@
 
 /**
  */
-public final class ImportEvent extends PrimitiveOp {
+public final class ImportEvent extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ImportEvent operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/MergeSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/MergeSummary.java
index 24f940928e3..32ec38a516a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/MergeSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/MergeSummary.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * in the summaries to merge use the same tag.
  */
 @Operator(group = "summary")
-public final class MergeSummary extends PrimitiveOp implements Operand<TString> {
+public final class MergeSummary extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new MergeSummary operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/ScalarSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/ScalarSummary.java
index 203e90a7db3..c766d9759ed 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/ScalarSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/ScalarSummary.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * has a summary value for each tag-value pair in `tags` and `values`.
  */
 @Operator(group = "summary")
-public final class ScalarSummary extends PrimitiveOp implements Operand<TString> {
+public final class ScalarSummary extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new ScalarSummary operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/StatsAggregatorSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/StatsAggregatorSummary.java
index f19d5563c77..525db2a64e8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/StatsAggregatorSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/StatsAggregatorSummary.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Produces a summary of any statistics recorded by the given statistics manager.
  */
-public final class StatsAggregatorSummary extends PrimitiveOp implements Operand<TString> {
+public final class StatsAggregatorSummary extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new StatsAggregatorSummary operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/SummaryWriter.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/SummaryWriter.java
index 2ceea84c710..f27b996b716 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/SummaryWriter.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/SummaryWriter.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
 
 /**
  */
-public final class SummaryWriter extends PrimitiveOp implements Operand<TType> {
+public final class SummaryWriter extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.summary.SummaryWriter}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/TensorSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/TensorSummary.java
index f5e8dcab91c..0d6e950a4f3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/TensorSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/TensorSummary.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * Outputs a `Summary` protocol buffer with a tensor and per-plugin data.
  */
 @Operator(group = "summary")
-public final class TensorSummary extends PrimitiveOp implements Operand<TString> {
+public final class TensorSummary extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new TensorSummary operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteAudioSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteAudioSummary.java
index e3e8bb22957..69e42753c7c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteAudioSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteAudioSummary.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 
 /**
  */
-public final class WriteAudioSummary extends PrimitiveOp {
+public final class WriteAudioSummary extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.summary.WriteAudioSummary}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteGraphSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteGraphSummary.java
index fcb07403d0b..0d6b11f1f6d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteGraphSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteGraphSummary.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
 
 /**
  */
-public final class WriteGraphSummary extends PrimitiveOp {
+public final class WriteGraphSummary extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new WriteGraphSummary operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteHistogramSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteHistogramSummary.java
index d5d6af4c972..1cfdc6bd095 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteHistogramSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteHistogramSummary.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
 
 /**
  */
-public final class WriteHistogramSummary extends PrimitiveOp {
+public final class WriteHistogramSummary extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new WriteHistogramSummary operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteImageSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteImageSummary.java
index aa7b8904c9b..26be4538bf0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteImageSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteImageSummary.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
 
 /**
  */
-public final class WriteImageSummary extends PrimitiveOp {
+public final class WriteImageSummary extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.summary.WriteImageSummary}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteRawProtoSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteRawProtoSummary.java
index 1eb4a94be53..e781534b31b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteRawProtoSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteRawProtoSummary.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
 
 /**
  */
-public final class WriteRawProtoSummary extends PrimitiveOp {
+public final class WriteRawProtoSummary extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new WriteRawProtoSummary operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteScalarSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteScalarSummary.java
index be392cf1344..b3a7b3a6723 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteScalarSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteScalarSummary.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
 
 /**
  */
-public final class WriteScalarSummary extends PrimitiveOp {
+public final class WriteScalarSummary extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new WriteScalarSummary operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteSummary.java
index b0225812cb0..a538b5a4cfd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/summary/WriteSummary.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 
 /**
  */
-public final class WriteSummary extends PrimitiveOp {
+public final class WriteSummary extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new WriteSummary operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/AllToAll.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/AllToAll.java
index f2f46409252..615657b1408 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/AllToAll.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/AllToAll.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -50,7 +50,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class AllToAll<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class AllToAll<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new AllToAll operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/CollectivePermute.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/CollectivePermute.java
index 7ef7d99c526..5b298bc1630 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/CollectivePermute.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/CollectivePermute.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class CollectivePermute<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class CollectivePermute<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new CollectivePermute operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/ConfigureDistributedTPU.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/ConfigureDistributedTPU.java
index 68d994edf0f..73f1bfceb3e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/ConfigureDistributedTPU.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/ConfigureDistributedTPU.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Sets up the centralized structures for a distributed TPU system.
  */
-public final class ConfigureDistributedTPU extends PrimitiveOp implements Operand<TString> {
+public final class ConfigureDistributedTPU extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.ConfigureDistributedTPU}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/ConfigureTPUEmbedding.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/ConfigureTPUEmbedding.java
index e2fdd82637d..d1fb1fa838d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/ConfigureTPUEmbedding.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/ConfigureTPUEmbedding.java
@@ -19,7 +19,7 @@
 
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -27,7 +27,7 @@
 /**
  * Sets up TPUEmbedding in a distributed TPU system.
  */
-public final class ConfigureTPUEmbedding extends PrimitiveOp {
+public final class ConfigureTPUEmbedding extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ConfigureTPUEmbedding operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/CrossReplicaSum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/CrossReplicaSum.java
index d8174b8d9fc..2c257fb6d2f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/CrossReplicaSum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/CrossReplicaSum.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class CrossReplicaSum<T extends TNumber> extends PrimitiveOp implements Operand<T> {
+public final class CrossReplicaSum<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new CrossReplicaSum operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/EnqueueTPUEmbeddingIntegerBatch.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/EnqueueTPUEmbeddingIntegerBatch.java
index 4182d3eeaef..7b499d87664 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/EnqueueTPUEmbeddingIntegerBatch.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/EnqueueTPUEmbeddingIntegerBatch.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
 /**
  * An op that enqueues a list of input batch tensors to TPUEmbedding.
  */
-public final class EnqueueTPUEmbeddingIntegerBatch extends PrimitiveOp {
+public final class EnqueueTPUEmbeddingIntegerBatch extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.EnqueueTPUEmbeddingIntegerBatch}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/EnqueueTPUEmbeddingSparseBatch.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/EnqueueTPUEmbeddingSparseBatch.java
index d82ad038dfa..35185704d89 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/EnqueueTPUEmbeddingSparseBatch.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/EnqueueTPUEmbeddingSparseBatch.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * must have the same shape, i.e. rank 1 with dim_size() equal to the total
  * number of lookups into the table described by the corresponding table_id.
  */
-public final class EnqueueTPUEmbeddingSparseBatch extends PrimitiveOp {
+public final class EnqueueTPUEmbeddingSparseBatch extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.EnqueueTPUEmbeddingSparseBatch}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/EnqueueTPUEmbeddingSparseTensorBatch.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/EnqueueTPUEmbeddingSparseTensorBatch.java
index c78944931cf..5e4bf1c6b27 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/EnqueueTPUEmbeddingSparseTensorBatch.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/EnqueueTPUEmbeddingSparseTensorBatch.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * with dim_size() equal to the total number of lookups into the table described by
  * the corresponding feature.
  */
-public final class EnqueueTPUEmbeddingSparseTensorBatch extends PrimitiveOp {
+public final class EnqueueTPUEmbeddingSparseTensorBatch extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.EnqueueTPUEmbeddingSparseTensorBatch}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedDequeue.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedDequeue.java
index 08073bae0a1..3d200e0267d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedDequeue.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedDequeue.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class InfeedDequeue<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class InfeedDequeue<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new InfeedDequeue operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedDequeueTuple.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedDequeueTuple.java
index 074a1194fa3..ef1e648e2de 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedDequeueTuple.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedDequeueTuple.java
@@ -25,7 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
 /**
  * Fetches multiple values from infeed as an XLA tuple.
  */
-public final class InfeedDequeueTuple extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class InfeedDequeueTuple extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new InfeedDequeueTuple operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedEnqueue.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedEnqueue.java
index de7e76ca0cd..e4bc54602c8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedEnqueue.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedEnqueue.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
 /**
  * An op which feeds a single Tensor value into the computation.
  */
-public final class InfeedEnqueue extends PrimitiveOp {
+public final class InfeedEnqueue extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.InfeedEnqueue}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedEnqueuePrelinearizedBuffer.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedEnqueuePrelinearizedBuffer.java
index b10c41c787a..cdd475a08ae 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedEnqueuePrelinearizedBuffer.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedEnqueuePrelinearizedBuffer.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -28,7 +28,7 @@
 /**
  * An op which enqueues prelinearized buffer into TPU infeed.
  */
-public final class InfeedEnqueuePrelinearizedBuffer extends PrimitiveOp {
+public final class InfeedEnqueuePrelinearizedBuffer extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.InfeedEnqueuePrelinearizedBuffer}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedEnqueueTuple.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedEnqueueTuple.java
index ef5409ac727..775501dac45 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedEnqueueTuple.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/InfeedEnqueueTuple.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
 /**
  * Feeds multiple Tensor values into the computation as an XLA tuple.
  */
-public final class InfeedEnqueueTuple extends PrimitiveOp {
+public final class InfeedEnqueueTuple extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.InfeedEnqueueTuple}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingADAMParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingADAMParameters.java
index cd223805ea1..1222247d109 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingADAMParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingADAMParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * parameters that are loaded from a checkpoint before a training loop is
  * executed.
  */
-public final class LoadTPUEmbeddingADAMParameters extends PrimitiveOp {
+public final class LoadTPUEmbeddingADAMParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.LoadTPUEmbeddingADAMParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingADAMParametersGradAccumDebug.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingADAMParametersGradAccumDebug.java
index d431120de41..53af351f736 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingADAMParametersGradAccumDebug.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingADAMParametersGradAccumDebug.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * parameters that are loaded from a checkpoint before a training loop is
  * executed.
  */
-public final class LoadTPUEmbeddingADAMParametersGradAccumDebug extends PrimitiveOp {
+public final class LoadTPUEmbeddingADAMParametersGradAccumDebug extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.LoadTPUEmbeddingADAMParametersGradAccumDebug}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingAdadeltaParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingAdadeltaParameters.java
index 711f676f6ff..66e2bc9a3d4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingAdadeltaParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingAdadeltaParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * parameters that are loaded from a checkpoint before a training loop is
  * executed.
  */
-public final class LoadTPUEmbeddingAdadeltaParameters extends PrimitiveOp {
+public final class LoadTPUEmbeddingAdadeltaParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.LoadTPUEmbeddingAdadeltaParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingAdadeltaParametersGradAccumDebug.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingAdadeltaParametersGradAccumDebug.java
index 6f78f8f0745..d659eb12ec3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingAdadeltaParametersGradAccumDebug.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingAdadeltaParametersGradAccumDebug.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * parameters that are loaded from a checkpoint before a training loop is
  * executed.
  */
-public final class LoadTPUEmbeddingAdadeltaParametersGradAccumDebug extends PrimitiveOp {
+public final class LoadTPUEmbeddingAdadeltaParametersGradAccumDebug extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.LoadTPUEmbeddingAdadeltaParametersGradAccumDebug}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingAdagradParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingAdagradParameters.java
index f9b60c0cce2..80b424e073c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingAdagradParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingAdagradParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * parameters that are loaded from a checkpoint before a training loop is
  * executed.
  */
-public final class LoadTPUEmbeddingAdagradParameters extends PrimitiveOp {
+public final class LoadTPUEmbeddingAdagradParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.LoadTPUEmbeddingAdagradParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingAdagradParametersGradAccumDebug.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingAdagradParametersGradAccumDebug.java
index 31110fdd23b..de11b50f1f9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingAdagradParametersGradAccumDebug.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingAdagradParametersGradAccumDebug.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * parameters that are loaded from a checkpoint before a training loop is
  * executed.
  */
-public final class LoadTPUEmbeddingAdagradParametersGradAccumDebug extends PrimitiveOp {
+public final class LoadTPUEmbeddingAdagradParametersGradAccumDebug extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.LoadTPUEmbeddingAdagradParametersGradAccumDebug}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingCenteredRMSPropParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingCenteredRMSPropParameters.java
index 1c24d0da4b0..b7bbb92fa90 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingCenteredRMSPropParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingCenteredRMSPropParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * parameters that are loaded from a checkpoint before a training loop is
  * executed.
  */
-public final class LoadTPUEmbeddingCenteredRMSPropParameters extends PrimitiveOp {
+public final class LoadTPUEmbeddingCenteredRMSPropParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.LoadTPUEmbeddingCenteredRMSPropParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingFTRLParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingFTRLParameters.java
index 66f4d9dd1c1..7939230997f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingFTRLParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingFTRLParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * parameters that are loaded from a checkpoint before a training loop is
  * executed.
  */
-public final class LoadTPUEmbeddingFTRLParameters extends PrimitiveOp {
+public final class LoadTPUEmbeddingFTRLParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.LoadTPUEmbeddingFTRLParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingFTRLParametersGradAccumDebug.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingFTRLParametersGradAccumDebug.java
index 94dd13409a9..38ebb8518bd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingFTRLParametersGradAccumDebug.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingFTRLParametersGradAccumDebug.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * parameters that are loaded from a checkpoint before a training loop is
  * executed.
  */
-public final class LoadTPUEmbeddingFTRLParametersGradAccumDebug extends PrimitiveOp {
+public final class LoadTPUEmbeddingFTRLParametersGradAccumDebug extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.LoadTPUEmbeddingFTRLParametersGradAccumDebug}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingMDLAdagradLightParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingMDLAdagradLightParameters.java
index f82a89e27a7..7d0f7d014c3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingMDLAdagradLightParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingMDLAdagradLightParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * parameters that are loaded from a checkpoint before a training loop is
  * executed.
  */
-public final class LoadTPUEmbeddingMDLAdagradLightParameters extends PrimitiveOp {
+public final class LoadTPUEmbeddingMDLAdagradLightParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.LoadTPUEmbeddingMDLAdagradLightParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingMomentumParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingMomentumParameters.java
index 05f8a7264c5..c705213c9a2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingMomentumParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingMomentumParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * parameters that are loaded from a checkpoint before a training loop is
  * executed.
  */
-public final class LoadTPUEmbeddingMomentumParameters extends PrimitiveOp {
+public final class LoadTPUEmbeddingMomentumParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.LoadTPUEmbeddingMomentumParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingMomentumParametersGradAccumDebug.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingMomentumParametersGradAccumDebug.java
index d22bf67533c..d774094df05 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingMomentumParametersGradAccumDebug.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingMomentumParametersGradAccumDebug.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * parameters that are loaded from a checkpoint before a training loop is
  * executed.
  */
-public final class LoadTPUEmbeddingMomentumParametersGradAccumDebug extends PrimitiveOp {
+public final class LoadTPUEmbeddingMomentumParametersGradAccumDebug extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.LoadTPUEmbeddingMomentumParametersGradAccumDebug}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingProximalAdagradParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingProximalAdagradParameters.java
index 049a40baa9b..57db2202b99 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingProximalAdagradParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingProximalAdagradParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * parameters that are loaded from a checkpoint before a training loop is
  * executed.
  */
-public final class LoadTPUEmbeddingProximalAdagradParameters extends PrimitiveOp {
+public final class LoadTPUEmbeddingProximalAdagradParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.LoadTPUEmbeddingProximalAdagradParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug.java
index 2cdcd582532..40eec1594f1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * parameters that are loaded from a checkpoint before a training loop is
  * executed.
  */
-public final class LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug extends PrimitiveOp {
+public final class LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingRMSPropParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingRMSPropParameters.java
index c48ce5928bc..88e2c035ce8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingRMSPropParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingRMSPropParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * parameters that are loaded from a checkpoint before a training loop is
  * executed.
  */
-public final class LoadTPUEmbeddingRMSPropParameters extends PrimitiveOp {
+public final class LoadTPUEmbeddingRMSPropParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.LoadTPUEmbeddingRMSPropParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingRMSPropParametersGradAccumDebug.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingRMSPropParametersGradAccumDebug.java
index 8972b758129..6e79a29f987 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingRMSPropParametersGradAccumDebug.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingRMSPropParametersGradAccumDebug.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * parameters that are loaded from a checkpoint before a training loop is
  * executed.
  */
-public final class LoadTPUEmbeddingRMSPropParametersGradAccumDebug extends PrimitiveOp {
+public final class LoadTPUEmbeddingRMSPropParametersGradAccumDebug extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.LoadTPUEmbeddingRMSPropParametersGradAccumDebug}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingStochasticGradientDescentParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingStochasticGradientDescentParameters.java
index e08b747fdaf..32b34ea6262 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingStochasticGradientDescentParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/LoadTPUEmbeddingStochasticGradientDescentParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * parameters that are loaded from a checkpoint before a training loop is
  * executed.
  */
-public final class LoadTPUEmbeddingStochasticGradientDescentParameters extends PrimitiveOp {
+public final class LoadTPUEmbeddingStochasticGradientDescentParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.LoadTPUEmbeddingStochasticGradientDescentParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/OutfeedDequeue.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/OutfeedDequeue.java
index 85da2bc85a2..0efb5a785b0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/OutfeedDequeue.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/OutfeedDequeue.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class OutfeedDequeue<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class OutfeedDequeue<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.OutfeedDequeue}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/OutfeedDequeueTuple.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/OutfeedDequeueTuple.java
index 2feca09d57c..7e9008b681e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/OutfeedDequeueTuple.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/OutfeedDequeueTuple.java
@@ -25,7 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * This operation will block indefinitely until data is available. Output `i`
  * corresponds to XLA tuple element `i`.
  */
-public final class OutfeedDequeueTuple extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class OutfeedDequeueTuple extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.OutfeedDequeueTuple}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/OutfeedEnqueue.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/OutfeedEnqueue.java
index 81332c7db05..16e8733bc55 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/OutfeedEnqueue.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/OutfeedEnqueue.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
 /**
  * Enqueue a Tensor on the computation outfeed.
  */
-public final class OutfeedEnqueue extends PrimitiveOp {
+public final class OutfeedEnqueue extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new OutfeedEnqueue operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/OutfeedEnqueueTuple.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/OutfeedEnqueueTuple.java
index ad84c360f50..43972c6f64a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/OutfeedEnqueueTuple.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/OutfeedEnqueueTuple.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
 /**
  * Enqueue multiple Tensor values on the computation outfeed.
  */
-public final class OutfeedEnqueueTuple extends PrimitiveOp {
+public final class OutfeedEnqueueTuple extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new OutfeedEnqueueTuple operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/Prelinearize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/Prelinearize.java
index c18b27120ca..b1e52557c00 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/Prelinearize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/Prelinearize.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
 /**
  * An op which linearizes one Tensor value to an opaque variant tensor.
  */
-public final class Prelinearize extends PrimitiveOp implements Operand<TType> {
+public final class Prelinearize extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.Prelinearize}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/PrelinearizeTuple.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/PrelinearizeTuple.java
index 3965e080242..a08e8e5712c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/PrelinearizeTuple.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/PrelinearizeTuple.java
@@ -23,7 +23,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
 /**
  * An op which linearizes multiple Tensor values to an opaque variant tensor.
  */
-public final class PrelinearizeTuple extends PrimitiveOp implements Operand<TType> {
+public final class PrelinearizeTuple extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.PrelinearizeTuple}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RecvTPUEmbeddingActivations.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RecvTPUEmbeddingActivations.java
index dc390a4f30a..9ed8bdf75bc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RecvTPUEmbeddingActivations.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RecvTPUEmbeddingActivations.java
@@ -24,7 +24,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * one Tensor of activations per table specified in the model. There can be at
  * most one RecvTPUEmbeddingActivations op in the TPU graph.
  */
-public final class RecvTPUEmbeddingActivations extends PrimitiveOp implements Iterable<Operand<TFloat32>> {
+public final class RecvTPUEmbeddingActivations extends RawOp implements Iterable<Operand<TFloat32>> {
   
   /**
    * Factory method to create a class wrapping a new RecvTPUEmbeddingActivations operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingADAMParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingADAMParameters.java
index adc29472d33..9f14bc5f984 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingADAMParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingADAMParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * the correct embedding table configuration. For example, this op is
  * used to retrieve updated parameters before saving a checkpoint.
  */
-public final class RetrieveTPUEmbeddingADAMParameters extends PrimitiveOp {
+public final class RetrieveTPUEmbeddingADAMParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.RetrieveTPUEmbeddingADAMParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingADAMParametersGradAccumDebug.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingADAMParametersGradAccumDebug.java
index 0fa05f97968..ba7a9aebf01 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingADAMParametersGradAccumDebug.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingADAMParametersGradAccumDebug.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * the correct embedding table configuration. For example, this op is
  * used to retrieve updated parameters before saving a checkpoint.
  */
-public final class RetrieveTPUEmbeddingADAMParametersGradAccumDebug extends PrimitiveOp {
+public final class RetrieveTPUEmbeddingADAMParametersGradAccumDebug extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.RetrieveTPUEmbeddingADAMParametersGradAccumDebug}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingAdadeltaParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingAdadeltaParameters.java
index f9beab9574e..b7235410fa1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingAdadeltaParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingAdadeltaParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * the correct embedding table configuration. For example, this op is
  * used to retrieve updated parameters before saving a checkpoint.
  */
-public final class RetrieveTPUEmbeddingAdadeltaParameters extends PrimitiveOp {
+public final class RetrieveTPUEmbeddingAdadeltaParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.RetrieveTPUEmbeddingAdadeltaParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingAdadeltaParametersGradAccumDebug.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingAdadeltaParametersGradAccumDebug.java
index 3fb334aa30b..5b563e92d70 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingAdadeltaParametersGradAccumDebug.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingAdadeltaParametersGradAccumDebug.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * the correct embedding table configuration. For example, this op is
  * used to retrieve updated parameters before saving a checkpoint.
  */
-public final class RetrieveTPUEmbeddingAdadeltaParametersGradAccumDebug extends PrimitiveOp {
+public final class RetrieveTPUEmbeddingAdadeltaParametersGradAccumDebug extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.RetrieveTPUEmbeddingAdadeltaParametersGradAccumDebug}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingAdagradParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingAdagradParameters.java
index 481f9b8677d..f79703b3de7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingAdagradParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingAdagradParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * the correct embedding table configuration. For example, this op is
  * used to retrieve updated parameters before saving a checkpoint.
  */
-public final class RetrieveTPUEmbeddingAdagradParameters extends PrimitiveOp {
+public final class RetrieveTPUEmbeddingAdagradParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.RetrieveTPUEmbeddingAdagradParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingAdagradParametersGradAccumDebug.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingAdagradParametersGradAccumDebug.java
index 097fb27a903..1ebf1ee8bee 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingAdagradParametersGradAccumDebug.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingAdagradParametersGradAccumDebug.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * the correct embedding table configuration. For example, this op is
  * used to retrieve updated parameters before saving a checkpoint.
  */
-public final class RetrieveTPUEmbeddingAdagradParametersGradAccumDebug extends PrimitiveOp {
+public final class RetrieveTPUEmbeddingAdagradParametersGradAccumDebug extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.RetrieveTPUEmbeddingAdagradParametersGradAccumDebug}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingCenteredRMSPropParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingCenteredRMSPropParameters.java
index fe9cce95f82..69fc77119ce 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingCenteredRMSPropParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingCenteredRMSPropParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * the correct embedding table configuration. For example, this op is
  * used to retrieve updated parameters before saving a checkpoint.
  */
-public final class RetrieveTPUEmbeddingCenteredRMSPropParameters extends PrimitiveOp {
+public final class RetrieveTPUEmbeddingCenteredRMSPropParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.RetrieveTPUEmbeddingCenteredRMSPropParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingFTRLParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingFTRLParameters.java
index 41ad4af99b1..556a2b5faa7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingFTRLParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingFTRLParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * the correct embedding table configuration. For example, this op is
  * used to retrieve updated parameters before saving a checkpoint.
  */
-public final class RetrieveTPUEmbeddingFTRLParameters extends PrimitiveOp {
+public final class RetrieveTPUEmbeddingFTRLParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.RetrieveTPUEmbeddingFTRLParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingFTRLParametersGradAccumDebug.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingFTRLParametersGradAccumDebug.java
index 65a59270864..f80357dd124 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingFTRLParametersGradAccumDebug.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingFTRLParametersGradAccumDebug.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * the correct embedding table configuration. For example, this op is
  * used to retrieve updated parameters before saving a checkpoint.
  */
-public final class RetrieveTPUEmbeddingFTRLParametersGradAccumDebug extends PrimitiveOp {
+public final class RetrieveTPUEmbeddingFTRLParametersGradAccumDebug extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.RetrieveTPUEmbeddingFTRLParametersGradAccumDebug}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingMDLAdagradLightParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingMDLAdagradLightParameters.java
index fe5f693d5b6..4b1ef14db2b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingMDLAdagradLightParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingMDLAdagradLightParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * the correct embedding table configuration. For example, this op is
  * used to retrieve updated parameters before saving a checkpoint.
  */
-public final class RetrieveTPUEmbeddingMDLAdagradLightParameters extends PrimitiveOp {
+public final class RetrieveTPUEmbeddingMDLAdagradLightParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.RetrieveTPUEmbeddingMDLAdagradLightParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingMomentumParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingMomentumParameters.java
index 0aba133eeb8..72732a3da00 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingMomentumParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingMomentumParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * the correct embedding table configuration. For example, this op is
  * used to retrieve updated parameters before saving a checkpoint.
  */
-public final class RetrieveTPUEmbeddingMomentumParameters extends PrimitiveOp {
+public final class RetrieveTPUEmbeddingMomentumParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.RetrieveTPUEmbeddingMomentumParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingMomentumParametersGradAccumDebug.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingMomentumParametersGradAccumDebug.java
index bdec44a221e..b8398bf62e9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingMomentumParametersGradAccumDebug.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingMomentumParametersGradAccumDebug.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * the correct embedding table configuration. For example, this op is
  * used to retrieve updated parameters before saving a checkpoint.
  */
-public final class RetrieveTPUEmbeddingMomentumParametersGradAccumDebug extends PrimitiveOp {
+public final class RetrieveTPUEmbeddingMomentumParametersGradAccumDebug extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.RetrieveTPUEmbeddingMomentumParametersGradAccumDebug}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingProximalAdagradParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingProximalAdagradParameters.java
index 67e4b2c3cf0..43c9daa0f1a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingProximalAdagradParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingProximalAdagradParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * the correct embedding table configuration. For example, this op is
  * used to retrieve updated parameters before saving a checkpoint.
  */
-public final class RetrieveTPUEmbeddingProximalAdagradParameters extends PrimitiveOp {
+public final class RetrieveTPUEmbeddingProximalAdagradParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.RetrieveTPUEmbeddingProximalAdagradParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug.java
index 4c9ea28cdcc..982e7c8bd44 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * the correct embedding table configuration. For example, this op is
  * used to retrieve updated parameters before saving a checkpoint.
  */
-public final class RetrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug extends PrimitiveOp {
+public final class RetrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.RetrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingRMSPropParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingRMSPropParameters.java
index 114915691c6..393cc2c482d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingRMSPropParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingRMSPropParameters.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * the correct embedding table configuration. For example, this op is
  * used to retrieve updated parameters before saving a checkpoint.
  */
-public final class RetrieveTPUEmbeddingRMSPropParameters extends PrimitiveOp {
+public final class RetrieveTPUEmbeddingRMSPropParameters extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.RetrieveTPUEmbeddingRMSPropParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingRMSPropParametersGradAccumDebug.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingRMSPropParametersGradAccumDebug.java
index db9026f53da..2e65ab437da 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingRMSPropParametersGradAccumDebug.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingRMSPropParametersGradAccumDebug.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * the correct embedding table configuration. For example, this op is
  * used to retrieve updated parameters before saving a checkpoint.
  */
-public final class RetrieveTPUEmbeddingRMSPropParametersGradAccumDebug extends PrimitiveOp {
+public final class RetrieveTPUEmbeddingRMSPropParametersGradAccumDebug extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.RetrieveTPUEmbeddingRMSPropParametersGradAccumDebug}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingStochasticGradientDescentParameters.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingStochasticGradientDescentParameters.java
index 89a7e40bbbe..c98b2b5f7a8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingStochasticGradientDescentParameters.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/RetrieveTPUEmbeddingStochasticGradientDescentParameters.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * the correct embedding table configuration. For example, this op is
  * used to retrieve updated parameters before saving a checkpoint.
  */
-public final class RetrieveTPUEmbeddingStochasticGradientDescentParameters extends PrimitiveOp implements Operand<TFloat32> {
+public final class RetrieveTPUEmbeddingStochasticGradientDescentParameters extends RawOp implements Operand<TFloat32> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.RetrieveTPUEmbeddingStochasticGradientDescentParameters}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/SendTPUEmbeddingGradients.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/SendTPUEmbeddingGradients.java
index a5a2a7b5a2c..87b07cd2b8a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/SendTPUEmbeddingGradients.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/SendTPUEmbeddingGradients.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Performs gradient updates of embedding tables.
  */
-public final class SendTPUEmbeddingGradients extends PrimitiveOp {
+public final class SendTPUEmbeddingGradients extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SendTPUEmbeddingGradients operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/ShutdownDistributedTPU.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/ShutdownDistributedTPU.java
index 884dc156474..5b424235074 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/ShutdownDistributedTPU.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/ShutdownDistributedTPU.java
@@ -19,7 +19,7 @@
 
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -29,7 +29,7 @@
  * <p>
  * The op returns an error if no system is running.
  */
-public final class ShutdownDistributedTPU extends PrimitiveOp {
+public final class ShutdownDistributedTPU extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ShutdownDistributedTPU operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUCompilationResult.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUCompilationResult.java
index c4bbe7b3725..d9bd22679e3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUCompilationResult.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUCompilationResult.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * CompilationResultProto, which holds a status and an error message if an error
  * occurred during compilation.
  */
-public final class TPUCompilationResult extends PrimitiveOp implements Operand<TString> {
+public final class TPUCompilationResult extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new TPUCompilationResult operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUEmbeddingActivations.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUEmbeddingActivations.java
index 01cb6b23a73..5473e957471 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUEmbeddingActivations.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUEmbeddingActivations.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * differentiation of graphs containing embeddings via the TPU Embedding Python
  * libraries.
  */
-public final class TPUEmbeddingActivations extends PrimitiveOp implements Operand<TFloat32> {
+public final class TPUEmbeddingActivations extends RawOp implements Operand<TFloat32> {
   
   /**
    * Factory method to create a class wrapping a new TPUEmbeddingActivations operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUOrdinalSelector.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUOrdinalSelector.java
index 7bfb9fb1af9..156f4b779fe 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUOrdinalSelector.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUOrdinalSelector.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * (for regular inference) to execute the TPU program on. The output is
  * consumed by TPUPartitionedCall.
  */
-public final class TPUOrdinalSelector extends PrimitiveOp implements Operand<TInt32> {
+public final class TPUOrdinalSelector extends RawOp implements Operand<TInt32> {
   
   /**
    * Factory method to create a class wrapping a new TPUOrdinalSelector operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUReplicateMetadata.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUReplicateMetadata.java
index 421ff7e9fec..547c12d64e4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUReplicateMetadata.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUReplicateMetadata.java
@@ -20,7 +20,7 @@
 import java.util.List;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
  * <p>
  * This operation holds the metadata common to operations of a `tpu.replicate()` computation subgraph.
  */
-public final class TPUReplicateMetadata extends PrimitiveOp {
+public final class TPUReplicateMetadata extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.TPUReplicateMetadata}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUReplicatedInput.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUReplicatedInput.java
index 2a2192021c0..29a79de8da3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUReplicatedInput.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUReplicatedInput.java
@@ -22,7 +22,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class TPUReplicatedInput<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TPUReplicatedInput<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.TPUReplicatedInput}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUReplicatedOutput.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUReplicatedOutput.java
index bb940700c71..17c0b5b7cf9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUReplicatedOutput.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/TPUReplicatedOutput.java
@@ -24,7 +24,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code outputs()} output
  */
-public final class TPUReplicatedOutput<T extends TType> extends PrimitiveOp implements Iterable<Operand<T>> {
+public final class TPUReplicatedOutput<T extends TType> extends RawOp implements Iterable<Operand<T>> {
   
   /**
    * Factory method to create a class wrapping a new TPUReplicatedOutput operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/WorkerHeartbeat.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/WorkerHeartbeat.java
index b3a852986bf..bb35afe9d09 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/WorkerHeartbeat.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/tpu/WorkerHeartbeat.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * Heartbeats may be sent periodically to indicate the coordinator is still active,
  * to retrieve the current worker status and to expedite shutdown when necessary.
  */
-public final class WorkerHeartbeat extends PrimitiveOp implements Operand<TString> {
+public final class WorkerHeartbeat extends RawOp implements Operand<TString> {
   
   /**
    * Factory method to create a class wrapping a new WorkerHeartbeat operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/AccumulatorApplyGradient.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/AccumulatorApplyGradient.java
index 8c549f2fe9a..c493d6daa72 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/AccumulatorApplyGradient.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/AccumulatorApplyGradient.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * Does not add if local_step is lesser than the accumulator's global_step.
  */
 @Operator(group = "train")
-public final class AccumulatorApplyGradient extends PrimitiveOp {
+public final class AccumulatorApplyGradient extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new AccumulatorApplyGradient operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/AccumulatorNumAccumulated.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/AccumulatorNumAccumulated.java
index 67ee8c390ce..8146deccf7d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/AccumulatorNumAccumulated.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/AccumulatorNumAccumulated.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * Returns the number of gradients aggregated in the given accumulators.
  */
 @Operator(group = "train")
-public final class AccumulatorNumAccumulated extends PrimitiveOp implements Operand<TInt32> {
+public final class AccumulatorNumAccumulated extends RawOp implements Operand<TInt32> {
   
   /**
    * Factory method to create a class wrapping a new AccumulatorNumAccumulated operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/AccumulatorSetGlobalStep.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/AccumulatorSetGlobalStep.java
index 36d9b8c0438..747fcc6b123 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/AccumulatorSetGlobalStep.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/AccumulatorSetGlobalStep.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * new_global_step.
  */
 @Operator(group = "train")
-public final class AccumulatorSetGlobalStep extends PrimitiveOp {
+public final class AccumulatorSetGlobalStep extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new AccumulatorSetGlobalStep operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/AccumulatorTakeGradient.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/AccumulatorTakeGradient.java
index beba2e4885e..23f24d3f675 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/AccumulatorTakeGradient.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/AccumulatorTakeGradient.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code average()} output
  */
 @Operator(group = "train")
-public final class AccumulatorTakeGradient<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class AccumulatorTakeGradient<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new AccumulatorTakeGradient operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdaMax.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdaMax.java
index 360f66d6be7..8153a364508 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdaMax.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdaMax.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * 
  * @param <T> data type for {@code out()} output
  */
-public final class ApplyAdaMax<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ApplyAdaMax<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdaMax}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdadelta.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdadelta.java
index 194bd142286..928e2ae0f4e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdadelta.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdadelta.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyAdadelta<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ApplyAdadelta<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdadelta}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdagrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdagrad.java
index 567124389b0..2a88b987503 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdagrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdagrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyAdagrad<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ApplyAdagrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdagrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdagradDa.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdagradDa.java
index 1e103d76b6f..e03d521353b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdagradDa.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdagradDa.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyAdagradDa<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ApplyAdagradDa<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdagradDa}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdagradV2.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdagradV2.java
index db22dce719f..aeaaddb103c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdagradV2.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdagradV2.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code out()} output
  */
-public final class ApplyAdagradV2<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ApplyAdagradV2<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdagradV2}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdam.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdam.java
index 7982bdeff56..c6b93126708 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdam.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAdam.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyAdam<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ApplyAdam<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdam}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAddSign.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAddSign.java
index 846a069dc73..d7ca57e1dce 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAddSign.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyAddSign.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyAddSign<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ApplyAddSign<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAddSign}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyCenteredRmsProp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyCenteredRmsProp.java
index db12ace1000..fb1735ca92c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyCenteredRmsProp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyCenteredRmsProp.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -52,7 +52,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyCenteredRmsProp<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ApplyCenteredRmsProp<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyCenteredRmsProp}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyFtrl.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyFtrl.java
index ae5414057fc..be5d7128ff8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyFtrl.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyFtrl.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyFtrl<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ApplyFtrl<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyFtrl}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyGradientDescent.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyGradientDescent.java
index 05d3e1e7175..8377b0594e0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyGradientDescent.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyGradientDescent.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyGradientDescent<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ApplyGradientDescent<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyGradientDescent}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyMomentum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyMomentum.java
index 9c67105d069..e342d49d607 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyMomentum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyMomentum.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyMomentum<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ApplyMomentum<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyMomentum}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyPowerSign.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyPowerSign.java
index f9851ef2fb6..c0332c9a840 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyPowerSign.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyPowerSign.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyPowerSign<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ApplyPowerSign<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyPowerSign}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyProximalAdagrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyProximalAdagrad.java
index e740408b8e8..0f3e9af018a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyProximalAdagrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyProximalAdagrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyProximalAdagrad<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ApplyProximalAdagrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyProximalAdagrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyProximalGradientDescent.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyProximalGradientDescent.java
index 41edd118fa5..7a28929d7e7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyProximalGradientDescent.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyProximalGradientDescent.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyProximalGradientDescent<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ApplyProximalGradientDescent<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyProximalGradientDescent}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyRmsProp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyRmsProp.java
index b22c0fb7ed5..53ff4e45b87 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyRmsProp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ApplyRmsProp.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyRmsProp<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ApplyRmsProp<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyRmsProp}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/BatchMatMul.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/BatchMatMul.java
index 2f9e3140cf9..6e1ae852143 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/BatchMatMul.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/BatchMatMul.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "train")
-public final class BatchMatMul<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class BatchMatMul<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.BatchMatMul}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ConditionalAccumulator.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ConditionalAccumulator.java
index 5b61ce8a9ca..1140d4ad9b9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ConditionalAccumulator.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ConditionalAccumulator.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * the accumulator.
  */
 @Operator(group = "train")
-public final class ConditionalAccumulator extends PrimitiveOp implements Operand<TString> {
+public final class ConditionalAccumulator extends RawOp implements Operand<TString> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ConditionalAccumulator}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/GenerateVocabRemapping.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/GenerateVocabRemapping.java
index 4d456b26ed8..f1d4fb5d792 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/GenerateVocabRemapping.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/GenerateVocabRemapping.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -62,7 +62,7 @@
  * does (as opposed to tf.feature_to_id(), which uses a CuckooTable).
  */
 @Operator(group = "train")
-public final class GenerateVocabRemapping extends PrimitiveOp {
+public final class GenerateVocabRemapping extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.GenerateVocabRemapping}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/MergeV2Checkpoints.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/MergeV2Checkpoints.java
index d4e33a1cf66..7807178f138 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/MergeV2Checkpoints.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/MergeV2Checkpoints.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -39,7 +39,7 @@
  * user-facing temporary locations.
  */
 @Operator(group = "train")
-public final class MergeV2Checkpoints extends PrimitiveOp {
+public final class MergeV2Checkpoints extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.MergeV2Checkpoints}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/NegTrain.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/NegTrain.java
index f6116b151ab..1a625589a1d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/NegTrain.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/NegTrain.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * Training via negative sampling.
  */
 @Operator(group = "train")
-public final class NegTrain extends PrimitiveOp {
+public final class NegTrain extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new NegTrain operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/PreventGradient.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/PreventGradient.java
index 5b2ccd24a1f..cbd17d82d2d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/PreventGradient.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/PreventGradient.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "train")
-public final class PreventGradient<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class PreventGradient<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.PreventGradient}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceAccumulatorApplyGradient.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceAccumulatorApplyGradient.java
index fa20e37247a..ee76a499d06 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceAccumulatorApplyGradient.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceAccumulatorApplyGradient.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * <p>
  * Does not add if local_step is lesser than the accumulator's global_step.
  */
-public final class ResourceAccumulatorApplyGradient extends PrimitiveOp {
+public final class ResourceAccumulatorApplyGradient extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ResourceAccumulatorApplyGradient operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceAccumulatorNumAccumulated.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceAccumulatorNumAccumulated.java
index 6c3555265b2..3ec9d5dc02c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceAccumulatorNumAccumulated.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceAccumulatorNumAccumulated.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
 /**
  * Returns the number of gradients aggregated in the given accumulators.
  */
-public final class ResourceAccumulatorNumAccumulated extends PrimitiveOp implements Operand<TInt32> {
+public final class ResourceAccumulatorNumAccumulated extends RawOp implements Operand<TInt32> {
   
   /**
    * Factory method to create a class wrapping a new ResourceAccumulatorNumAccumulated operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceAccumulatorSetGlobalStep.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceAccumulatorSetGlobalStep.java
index 4e5ae27f5f1..d7f8261bc11 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceAccumulatorSetGlobalStep.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceAccumulatorSetGlobalStep.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * Logs warning if the accumulator's value is already higher than
  * new_global_step.
  */
-public final class ResourceAccumulatorSetGlobalStep extends PrimitiveOp {
+public final class ResourceAccumulatorSetGlobalStep extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new ResourceAccumulatorSetGlobalStep operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceAccumulatorTakeGradient.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceAccumulatorTakeGradient.java
index ef0aa2b196a..ab334ce4cc0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceAccumulatorTakeGradient.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceAccumulatorTakeGradient.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * 
  * @param <T> data type for {@code average()} output
  */
-public final class ResourceAccumulatorTakeGradient<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class ResourceAccumulatorTakeGradient<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ResourceAccumulatorTakeGradient operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdaMax.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdaMax.java
index b9247821baf..c22944b05c8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdaMax.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdaMax.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * v_t <- max(beta2 * v_{t-1}, abs(g))
  * variable <- variable - learning_rate / (1 - beta1^t) * m_t / (v_t + epsilon)
  */
-public final class ResourceApplyAdaMax extends PrimitiveOp {
+public final class ResourceApplyAdaMax extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceApplyAdaMax}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdadelta.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdadelta.java
index 1005309c842..8a947bc150e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdadelta.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdadelta.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * var -= update;
  */
 @Operator(group = "train")
-public final class ResourceApplyAdadelta extends PrimitiveOp {
+public final class ResourceApplyAdadelta extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceApplyAdadelta}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdagrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdagrad.java
index b26a49b6c15..33ae02d0f59 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdagrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdagrad.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * accum += grad * grad
  * var -= lr * grad * (1 / sqrt(accum))
  */
-public final class ResourceApplyAdagrad extends PrimitiveOp {
+public final class ResourceApplyAdagrad extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceApplyAdagrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdagradDa.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdagradDa.java
index bc69e7f0d27..ffb77721112 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdagradDa.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdagradDa.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Update '*var' according to the proximal adagrad scheme.
  */
 @Operator(group = "train")
-public final class ResourceApplyAdagradDa extends PrimitiveOp {
+public final class ResourceApplyAdagradDa extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceApplyAdagradDa}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdam.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdam.java
index 8d14e46454f..602eea7707d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdam.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdam.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * $$variable := variable - lr_t * m_t / (\sqrt{v_t} + \epsilon)$$
  */
 @Operator(group = "train")
-public final class ResourceApplyAdam extends PrimitiveOp {
+public final class ResourceApplyAdam extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceApplyAdam}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdamWithAmsgrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdamWithAmsgrad.java
index 90ebba8341e..2bd92cb0ea0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdamWithAmsgrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAdamWithAmsgrad.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -36,7 +36,7 @@
  * $$variable := variable - lr_t * m_t / (\sqrt{vhat_t} + \epsilon)$$
  */
 @Operator(group = "train")
-public final class ResourceApplyAdamWithAmsgrad extends PrimitiveOp {
+public final class ResourceApplyAdamWithAmsgrad extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceApplyAdamWithAmsgrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAddSign.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAddSign.java
index ec88a27ea45..82489d348da 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAddSign.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyAddSign.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * variable <- variable - lr_t * update
  */
 @Operator(group = "train")
-public final class ResourceApplyAddSign extends PrimitiveOp {
+public final class ResourceApplyAddSign extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceApplyAddSign}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyCenteredRmsProp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyCenteredRmsProp.java
index 6399973ef55..d76224d6022 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyCenteredRmsProp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyCenteredRmsProp.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -49,7 +49,7 @@
  * var <- var - mom
  */
 @Operator(group = "train")
-public final class ResourceApplyCenteredRmsProp extends PrimitiveOp {
+public final class ResourceApplyCenteredRmsProp extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceApplyCenteredRmsProp}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyFtrl.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyFtrl.java
index 6226ebb28f1..fcd57ba714b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyFtrl.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyFtrl.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * accum = accum_new
  */
 @Operator(group = "train")
-public final class ResourceApplyFtrl extends PrimitiveOp {
+public final class ResourceApplyFtrl extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceApplyFtrl}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyGradientDescent.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyGradientDescent.java
index e04d2ff8966..a57d2e90a18 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyGradientDescent.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyGradientDescent.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -30,7 +30,7 @@
  * Update '*var' by subtracting 'alpha' * 'delta' from it.
  */
 @Operator(group = "train")
-public final class ResourceApplyGradientDescent extends PrimitiveOp {
+public final class ResourceApplyGradientDescent extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceApplyGradientDescent}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyKerasMomentum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyKerasMomentum.java
index 537ba697c7b..883a688581c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyKerasMomentum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyKerasMomentum.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * var += accum
  */
 @Operator(group = "train")
-public final class ResourceApplyKerasMomentum extends PrimitiveOp {
+public final class ResourceApplyKerasMomentum extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceApplyKerasMomentum}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyMomentum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyMomentum.java
index 704021c9818..51af89430d2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyMomentum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyMomentum.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * var -= lr * accum
  */
 @Operator(group = "train")
-public final class ResourceApplyMomentum extends PrimitiveOp {
+public final class ResourceApplyMomentum extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceApplyMomentum}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyPowerSign.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyPowerSign.java
index ca4833190cd..5f035f53935 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyPowerSign.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyPowerSign.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * variable <- variable - lr_t * update
  */
 @Operator(group = "train")
-public final class ResourceApplyPowerSign extends PrimitiveOp {
+public final class ResourceApplyPowerSign extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceApplyPowerSign}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyProximalAdagrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyProximalAdagrad.java
index 625efa71334..e2197540e94 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyProximalAdagrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyProximalAdagrad.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * var = sign(prox_v)/(1+lr</i>l2) <i> max{|prox_v|-lr</i>l1,0}
  */
 @Operator(group = "train")
-public final class ResourceApplyProximalAdagrad extends PrimitiveOp {
+public final class ResourceApplyProximalAdagrad extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceApplyProximalAdagrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyProximalGradientDescent.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyProximalGradientDescent.java
index d200c5368b3..d5b9d063a95 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyProximalGradientDescent.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyProximalGradientDescent.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -33,7 +33,7 @@
  * var = sign(prox_v)/(1+alpha</i>l2) <i> max{|prox_v|-alpha</i>l1,0}
  */
 @Operator(group = "train")
-public final class ResourceApplyProximalGradientDescent extends PrimitiveOp {
+public final class ResourceApplyProximalGradientDescent extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceApplyProximalGradientDescent}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyRmsProp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyRmsProp.java
index 5a2f301dff2..f79a1202f6a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyRmsProp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceApplyRmsProp.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * var <- var - mom
  */
 @Operator(group = "train")
-public final class ResourceApplyRmsProp extends PrimitiveOp {
+public final class ResourceApplyRmsProp extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceApplyRmsProp}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceConditionalAccumulator.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceConditionalAccumulator.java
index d813a3553b6..c93104ae7c9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceConditionalAccumulator.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceConditionalAccumulator.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * This is a resource version of ConditionalAccumulator that will work in TF2.0
  * with tf.cond version 2.
  */
-public final class ResourceConditionalAccumulator extends PrimitiveOp implements Operand<TType> {
+public final class ResourceConditionalAccumulator extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceConditionalAccumulator}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyAdadelta.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyAdadelta.java
index ab8c202cce6..d64efcb9474 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyAdadelta.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyAdadelta.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * var: Should be from a Variable().
  */
 @Operator(group = "train")
-public final class ResourceSparseApplyAdadelta extends PrimitiveOp {
+public final class ResourceSparseApplyAdadelta extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceSparseApplyAdadelta}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyAdagrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyAdagrad.java
index e91c8c1edb0..6ece72cb637 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyAdagrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyAdagrad.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * var -= lr * grad * (1 / sqrt(accum))
  */
 @Operator(group = "train")
-public final class ResourceSparseApplyAdagrad extends PrimitiveOp {
+public final class ResourceSparseApplyAdagrad extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceSparseApplyAdagrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyAdagradDa.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyAdagradDa.java
index d00848a6118..ad007159e6a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyAdagradDa.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyAdagradDa.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * Update entries in '*var' and '*accum' according to the proximal adagrad scheme.
  */
 @Operator(group = "train")
-public final class ResourceSparseApplyAdagradDa extends PrimitiveOp {
+public final class ResourceSparseApplyAdagradDa extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceSparseApplyAdagradDa}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyAdagradV2.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyAdagradV2.java
index 41695a5b67c..f8808aa3980 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyAdagradV2.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyAdagradV2.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * accum += grad * grad
  * var -= lr * grad * (1 / sqrt(accum))
  */
-public final class ResourceSparseApplyAdagradV2 extends PrimitiveOp {
+public final class ResourceSparseApplyAdagradV2 extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceSparseApplyAdagradV2}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyCenteredRmsProp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyCenteredRmsProp.java
index 50bd4b4583d..e9482879729 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyCenteredRmsProp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyCenteredRmsProp.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -48,7 +48,7 @@
  * var <- var - mom
  */
 @Operator(group = "train")
-public final class ResourceSparseApplyCenteredRmsProp extends PrimitiveOp {
+public final class ResourceSparseApplyCenteredRmsProp extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceSparseApplyCenteredRmsProp}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyFtrl.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyFtrl.java
index 460e7e9508d..872dc72055e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyFtrl.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyFtrl.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * accum = accum_new
  */
 @Operator(group = "train")
-public final class ResourceSparseApplyFtrl extends PrimitiveOp {
+public final class ResourceSparseApplyFtrl extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceSparseApplyFtrl}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyKerasMomentum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyKerasMomentum.java
index 96d8da46fd1..e1ff036c295 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyKerasMomentum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyKerasMomentum.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * var += accum
  */
 @Operator(group = "train")
-public final class ResourceSparseApplyKerasMomentum extends PrimitiveOp {
+public final class ResourceSparseApplyKerasMomentum extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceSparseApplyKerasMomentum}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyMomentum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyMomentum.java
index 0d210ff7fd6..80c58d282bc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyMomentum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyMomentum.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * var -= lr * accum
  */
 @Operator(group = "train")
-public final class ResourceSparseApplyMomentum extends PrimitiveOp {
+public final class ResourceSparseApplyMomentum extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceSparseApplyMomentum}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyProximalAdagrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyProximalAdagrad.java
index ae4a6a6377f..75e7ca9e0f1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyProximalAdagrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyProximalAdagrad.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * var = sign(prox_v)/(1+lr</i>l2) <i> max{|prox_v|-lr</i>l1,0}
  */
 @Operator(group = "train")
-public final class ResourceSparseApplyProximalAdagrad extends PrimitiveOp {
+public final class ResourceSparseApplyProximalAdagrad extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceSparseApplyProximalAdagrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyProximalGradientDescent.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyProximalGradientDescent.java
index 4fa31d077ee..bf48496179c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyProximalGradientDescent.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyProximalGradientDescent.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * var = sign(prox_v)/(1+alpha</i>l2) <i> max{|prox_v|-alpha</i>l1,0}
  */
 @Operator(group = "train")
-public final class ResourceSparseApplyProximalGradientDescent extends PrimitiveOp {
+public final class ResourceSparseApplyProximalGradientDescent extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceSparseApplyProximalGradientDescent}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyRmsProp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyRmsProp.java
index fb1108ae16a..0dc980bb6f8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyRmsProp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/ResourceSparseApplyRmsProp.java
@@ -20,7 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * var <- var - mom
  */
 @Operator(group = "train")
-public final class ResourceSparseApplyRmsProp extends PrimitiveOp {
+public final class ResourceSparseApplyRmsProp extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceSparseApplyRmsProp}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/Restore.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/Restore.java
index 564359dd9b8..ecd4a059793 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/Restore.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/Restore.java
@@ -25,7 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -50,7 +50,7 @@
  * Callers must ensure all the named tensors are indeed stored in the checkpoint.
  */
 @Operator(group = "train")
-public final class Restore extends PrimitiveOp implements Iterable<Operand<TType>> {
+public final class Restore extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new Restore operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/RestoreSlice.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/RestoreSlice.java
index c849bceb682..e1148129d86 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/RestoreSlice.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/RestoreSlice.java
@@ -22,7 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code tensor()} output
  */
 @Operator(group = "train")
-public final class RestoreSlice<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class RestoreSlice<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.RestoreSlice}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/Save.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/Save.java
index c6728463ddf..b33f1c1c33b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/Save.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/Save.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * and correspondingly well-formed.
  */
 @Operator(group = "train")
-public final class Save extends PrimitiveOp {
+public final class Save extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new Save operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SaveSlices.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SaveSlices.java
index 3e21dcb2d70..25c91540ede 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SaveSlices.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SaveSlices.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -61,7 +61,7 @@
  * See also `Save`.
  */
 @Operator(group = "train")
-public final class SaveSlices extends PrimitiveOp {
+public final class SaveSlices extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SaveSlices operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SdcaFprint.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SdcaFprint.java
index cae42a97370..b5629b59b88 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SdcaFprint.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SdcaFprint.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -32,7 +32,7 @@
  * Computes fingerprints of the input strings.
  */
 @Operator(group = "train")
-public final class SdcaFprint extends PrimitiveOp implements Operand<TInt64> {
+public final class SdcaFprint extends RawOp implements Operand<TInt64> {
   
   /**
    * Factory method to create a class wrapping a new SdcaFprint operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SdcaOptimizer.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SdcaOptimizer.java
index 28a5e7d4535..9cf443dc4d8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SdcaOptimizer.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SdcaOptimizer.java
@@ -24,7 +24,7 @@
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -52,7 +52,7 @@
  * [Stochastic Dual Coordinate Ascent with Adaptive Probabilities](https://arxiv.org/abs/1502.08053).<br>
  * Dominik Csiba, Zheng Qu, Peter Richtarik. 2015
  */
-public final class SdcaOptimizer extends PrimitiveOp {
+public final class SdcaOptimizer extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SdcaOptimizer}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SdcaShrinkL1.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SdcaShrinkL1.java
index ae0ed6e0db6..d531030e063 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SdcaShrinkL1.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SdcaShrinkL1.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.op.Operands;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +31,7 @@
  * Applies L1 regularization shrink step on the parameters.
  */
 @Operator(group = "train")
-public final class SdcaShrinkL1 extends PrimitiveOp {
+public final class SdcaShrinkL1 extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SdcaShrinkL1 operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyAdadelta.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyAdadelta.java
index e0933cba0f5..6ed5c2faee3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyAdadelta.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyAdadelta.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyAdadelta<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SparseApplyAdadelta<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyAdadelta}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyAdagrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyAdagrad.java
index 1fff28158cd..90cbe36a32d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyAdagrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyAdagrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -37,7 +37,7 @@
  * 
  * @param <T> data type for {@code out()} output
  */
-public final class SparseApplyAdagrad<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SparseApplyAdagrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyAdagrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyAdagradDa.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyAdagradDa.java
index e726c38d033..23c791a6d50 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyAdagradDa.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyAdagradDa.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyAdagradDa<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SparseApplyAdagradDa<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyAdagradDa}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyCenteredRmsProp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyCenteredRmsProp.java
index 813bb82ec0c..367de145c5e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyCenteredRmsProp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyCenteredRmsProp.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -51,7 +51,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyCenteredRmsProp<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SparseApplyCenteredRmsProp<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyCenteredRmsProp}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyFtrl.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyFtrl.java
index 2fa843b612f..1e794a18788 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyFtrl.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyFtrl.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyFtrl<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SparseApplyFtrl<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyFtrl}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyMomentum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyMomentum.java
index 2c99494bb78..ebd4d0e7c14 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyMomentum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyMomentum.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyMomentum<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SparseApplyMomentum<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyMomentum}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyProximalAdagrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyProximalAdagrad.java
index 6c5f1cdcfcf..0a73d0a138c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyProximalAdagrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyProximalAdagrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyProximalAdagrad<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SparseApplyProximalAdagrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyProximalAdagrad}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyProximalGradientDescent.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyProximalGradientDescent.java
index 8242f61f688..2a4ef9f900b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyProximalGradientDescent.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyProximalGradientDescent.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyProximalGradientDescent<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SparseApplyProximalGradientDescent<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyProximalGradientDescent}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyRmsProp.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyRmsProp.java
index a9f024ab756..5205086b7dd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyRmsProp.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/SparseApplyRmsProp.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyRmsProp<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class SparseApplyRmsProp<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyRmsProp}
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/TileGrad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/TileGrad.java
index 4e91e671722..42d68f0f59b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/TileGrad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/train/TileGrad.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "train")
-public final class TileGrad<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class TileGrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TileGrad operation.
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Graph.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Graph.java
index a5cd59c0d0e..041befd4d26 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Graph.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Graph.java
@@ -40,6 +40,7 @@
 import org.tensorflow.internal.c_api.TF_Output;
 import org.tensorflow.internal.c_api.TF_Status;
 import org.tensorflow.internal.c_api.TF_WhileParams;
+import org.tensorflow.op.Op;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.core.NoOp;
 
@@ -177,7 +178,7 @@ public byte[] toGraphDef() {
    * Adds an initializer to the graph initializer list.
    * @param initializer An initializer to add to the list.
    */
-  public synchronized void addInitializer(Operand<?> initializer) {
+  public synchronized void addInitializer(Op initializer) {
     initializers.add(initializer);
   }
 
@@ -407,7 +408,7 @@ public Output<?>[] whileLoop(
   private TF_Graph nativeHandle;
   private int refcount = 0;
 
-  private final List<Operand<?>> initializers = new ArrayList<>();
+  private final List<Op> initializers = new ArrayList<>();
 
   // Related native objects (such as the TF_Operation object backing an Operation instance)
   // have a validity tied to that of the Graph. The handles to those native objects are not
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Operand.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Operand.java
index c9760b8e9c4..fa21f32d4ce 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Operand.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Operand.java
@@ -15,6 +15,7 @@
 
 package org.tensorflow;
 
+import org.tensorflow.op.Op;
 import org.tensorflow.types.family.TType;
 
 /**
@@ -38,7 +39,7 @@
  * tf.concat(split, tf.constant(0));
  * }</pre>
  */
-public interface Operand<T extends TType> {
+public interface Operand<T extends TType> extends Op {
 
   /**
    * Returns the symbolic handle of the tensor.
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Output.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Output.java
index 2e10a22f89e..dc81952f576 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Output.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Output.java
@@ -31,11 +31,6 @@
  */
 public final class Output<T extends TType> implements Operand<T> {
 
-  /** Returns the Operation that will produce the tensor referred to by this Output. */
-  public Operation op() {
-    return operation;
-  }
-
   /** Returns the index into the outputs of the Operation. */
   public int index() {
     return index;
@@ -71,6 +66,11 @@ public Tensor<T> tensor() {
     return (Tensor<T>) operation.tensor(index);
   }
 
+  @Override
+  public Operation op() {
+    return operation;
+  }
+
   @Override
   public Output<T> asOutput() {
     return this;
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/Op.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/Op.java
index e7b347505a3..40b54393c60 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/Op.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/Op.java
@@ -15,21 +15,37 @@
 
 package org.tensorflow.op;
 
+import org.tensorflow.Operation;
+
 /**
- * A marker interface for all operation wrappers.
- *
- * <p>Operation wrappers provide strongly typed interfaces for building and execution operations
- * without the use of literals and indexes, as required in the core classes.
+ * A logical unit of computation.
  *
- * <p>This interface allows keeping references to any operation wrapper using a common type.
+ * <p>{@code Op} implementations provide a strongly typed API for building and executing
+ * operations without the use of literals and indexes, as required in internal classes like
+ * {@link Operation}.
  *
- * <pre>{@code
- * // All values returned by an Ops call can be referred as a Op
- * Op split = ops.split(...);
- * Op add = ops.math.add(...);
- *
- * // All operations could be added to an Op collection
- * Collection<Op> allOps = Arrays.asList(split, add);
- * }
+ * <p>Ops can be classified under two categories:
+ * <ul>
+ * <li><i>{@link RawOp Raw} ops</i> target a single TensorFlow operation and are, in most cases,
+ * generated automatically from the {@code OpDef} proto definitions exposed by TensorFlow runtime
+ * library.</li>
+ * <li><i>Composite ops</i> execute a series of other ops to accomplish a task logically presented
+ * as a single unit of computation.
+ * </ul>
  */
-public interface Op {}
+public interface Op {
+
+  /**
+   * Return this unit of computation as a single {@link Operation}.
+   *
+   * <p>For a {@link RawOp raw} op, the returned value correspond to the TensorFlow operation
+   * wrapped by this op.
+   *
+   * <p>For a composite op, the returned value usually correspond to the last operation invoked in a
+   * chain or to a {@link org.tensorflow.op.core.NoOp NoOp} grouping one or more operations as a
+   * single unit of computation.
+   *
+   * @return an {@link Operation}
+   */
+  Operation op();
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/PrimitiveOp.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/RawOp.java
similarity index 77%
rename from tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/PrimitiveOp.java
rename to tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/RawOp.java
index 006ae99dc46..53137a84b54 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/PrimitiveOp.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/RawOp.java
@@ -20,12 +20,12 @@
 /**
  * A base class for {@link Op} implementations that are backed by a single {@link Operation}.
  *
- * <p>Each operation registered in the TensorFlow core is a primitive and is provided as a {@code
- * PrimitiveOp}. Custom operations working with only one primitive may also derive from this class.
+ * <p>Each operation registered in the TensorFlow core is provided as a {@code RawOp}. Custom
+ * operations working with only a single operation may also derive from this class.
  */
-public abstract class PrimitiveOp implements Op {
+public abstract class RawOp implements Op {
 
-  /** Returns the underlying {@link Operation} */
+  @Override
   public Operation op() {
     return operation;
   }
@@ -42,10 +42,10 @@ public final boolean equals(Object obj) {
     }
     // Note: we consider that all objects wrapping the same operation are equal, no matter their
     // implementation
-    if (!(obj instanceof PrimitiveOp)) {
+    if (!(obj instanceof RawOp)) {
       return false;
     }
-    return operation.equals(((PrimitiveOp) obj).operation);
+    return operation.equals(((RawOp) obj).operation);
   }
 
   @Override
@@ -60,7 +60,7 @@ public final String toString() {
    *
    * @param operation the underlying operation
    */
-  protected PrimitiveOp(Operation operation) {
+  protected RawOp(Operation operation) {
     this.operation = operation;
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/Scope.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/Scope.java
index 1562a1ed519..3d39685c7a4 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/Scope.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/Scope.java
@@ -17,7 +17,6 @@
 
 import java.util.ArrayList;
 import org.tensorflow.ExecutionEnvironment;
-import org.tensorflow.Operand;
 import org.tensorflow.OperationBuilder;
 
 /**
@@ -150,7 +149,7 @@ public String makeOpName(String defaultName) {
   }
 
   private Scope(
-      ExecutionEnvironment env, NameScope nameScope, Iterable<Operand<?>> controlDependencies) {
+      ExecutionEnvironment env, NameScope nameScope, Iterable<Op> controlDependencies) {
     this.env = env;
     this.nameScope = nameScope;
     this.controlDependencies = controlDependencies;
@@ -165,7 +164,7 @@ private Scope(
    * @param controls control dependencies for ops created with the returned scope
    * @return a new scope with the provided control dependencies
    */
-  public Scope withControlDependencies(Iterable<Operand<?>> controls) {
+  public Scope withControlDependencies(Iterable<Op> controls) {
     return new Scope(env, nameScope, controls);
   }
 
@@ -175,13 +174,13 @@ public Scope withControlDependencies(Iterable<Operand<?>> controls) {
    * @param builder OperationBuilder to add control inputs to
    */
   public OperationBuilder applyControlDependencies(OperationBuilder builder) {
-    for (Operand<?> control : controlDependencies) {
-      builder = builder.addControlInput(control.asOutput().op());
+    for (Op control : controlDependencies) {
+      builder = builder.addControlInput(control.op());
     }
     return builder;
   }
 
   private final ExecutionEnvironment env;
-  private final Iterable<Operand<?>> controlDependencies;
+  private final Iterable<Op> controlDependencies;
   private final NameScope nameScope;
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/annotation/Operator.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/annotation/Operator.java
index 057150eb047..dc995509a05 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/annotation/Operator.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/annotation/Operator.java
@@ -66,7 +66,7 @@
    *
    * <pre>{@code
    * @Operator(group="math")
-   * public final class Add extends PrimitiveOp implements Operand {
+   * public final class Add extends RawOp implements Operand {
    *   ...
    * }
    * }</pre>
@@ -83,7 +83,7 @@
    *
    * <pre>{@code
    * @Operator(group="data.experimental")
-   * public final class MyDataset extends PrimitiveOp implements Operand {
+   * public final class MyDataset extends RawOp implements Operand {
    *   ...
    * }
    * }</pre>
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Constant.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Constant.java
index fa4e489452d..ef1ccaf0256 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Constant.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Constant.java
@@ -21,7 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.Output;
 import org.tensorflow.Tensor;
-import org.tensorflow.op.PrimitiveOp;
+import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -66,7 +66,7 @@
  * }</pre>
  */
 @Operator
-public final class Constant<T extends TType> extends PrimitiveOp implements Operand<T> {
+public final class Constant<T extends TType> extends RawOp implements Operand<T> {
 
   /**
    * Creates a constant containing a single {@code int} element.
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Gradients.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Gradients.java
index cd71be8f032..2827276c32c 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Gradients.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Gradients.java
@@ -50,7 +50,7 @@
  * }</pre>
  */
 @Operator
-public final class Gradients implements Op, Iterable<Operand<?>> {
+public final class Gradients implements Iterable<Operand<?>> {
 
   /**
    * Optional attributes for {@link Gradients}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Zeros.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Zeros.java
index 217d590e6c3..4aad417b117 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Zeros.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Zeros.java
@@ -16,6 +16,7 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
+import org.tensorflow.Operation;
 import org.tensorflow.Output;
 import org.tensorflow.op.Op;
 import org.tensorflow.op.Scope;
@@ -61,6 +62,11 @@ public static <T extends TType, U extends TNumber> Zeros<T> create(Scope scope,
     return new Zeros<>(Fill.create(zerosScope.withName("Fill"), dims, zero));
   }
 
+  @Override
+  public Operation op() {
+    return fill.op();
+  }
+
   @Override
   public Output<T> asOutput() {
     return fill.asOutput();
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/PrimitiveOpTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/RawOpTest.java
similarity index 79%
rename from tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/PrimitiveOpTest.java
rename to tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/RawOpTest.java
index c0938836867..25a29d259f8 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/PrimitiveOpTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/RawOpTest.java
@@ -29,9 +29,9 @@
 import org.tensorflow.Output;
 import org.tensorflow.types.TInt32;
 
-/** Unit tests for {@link org.tensorflow.op.PrimitiveOp} */
+/** Unit tests for {@link RawOp} */
 @RunWith(JUnit4.class)
-public class PrimitiveOpTest {
+public class RawOpTest {
 
   @Test
   public void equalsHashcode() {
@@ -40,11 +40,11 @@ public void equalsHashcode() {
 
       Output<TInt32> array = tf.constant(new int[2]).asOutput();
 
-      PrimitiveOp test1 =
-          new PrimitiveOp(g.opBuilder("Shape", "shape1").addInput(array).build()) {};
-      PrimitiveOp test2 =
-          new PrimitiveOp(g.opBuilder("Shape", "shape2").addInput(array).build()) {};
-      PrimitiveOp test3 = new PrimitiveOp(test1.operation) {};
+      RawOp test1 =
+          new RawOp(g.opBuilder("Shape", "shape1").addInput(array).build()) {};
+      RawOp test2 =
+          new RawOp(g.opBuilder("Shape", "shape2").addInput(array).build()) {};
+      RawOp test3 = new RawOp(test1.operation) {};
 
       // equals() tests
       assertNotEquals(test1, test2);
@@ -53,7 +53,7 @@ public void equalsHashcode() {
       assertNotEquals(test2, test3);
 
       // hashcode() tests
-      Set<PrimitiveOp> ops = new HashSet<>();
+      Set<RawOp> ops = new HashSet<>();
       assertTrue(ops.add(test1));
       assertTrue(ops.add(test2));
       assertFalse(ops.add(test3));
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/GeneratedOperationsTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/GeneratedOperationsTest.java
index 7fd3dde2071..1c4e001bd6d 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/GeneratedOperationsTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/GeneratedOperationsTest.java
@@ -25,6 +25,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Session;
 import org.tensorflow.Tensor;
+import org.tensorflow.op.Op;
 import org.tensorflow.op.Ops;
 import org.tensorflow.tools.Shape;
 import org.tensorflow.types.TInt32;
@@ -74,7 +75,7 @@ public void testControlDependencies() {
       Ops ops = Ops.create(g);
       Operand<TInt32> variable = ops.variable(Shape.scalar(), TInt32.DTYPE);
       Operand<?> initVariable = ops.assign(variable, ops.constant(0));
-      ArrayList<Operand<?>> controls = new ArrayList<>();
+      ArrayList<Op> controls = new ArrayList<>();
       controls.add(ops.assign(variable, ops.constant(3)));
       Operand<TInt32> x =
           ops.withControlDependencies(controls).math.add(variable, ops.constant(0));
diff --git a/tensorflow-core/tensorflow-core-generator/src/main/java/org/tensorflow/processor/operator/OperatorProcessor.java b/tensorflow-core/tensorflow-core-generator/src/main/java/org/tensorflow/processor/operator/OperatorProcessor.java
index 52187ffdb88..4986d3c63a9 100644
--- a/tensorflow-core/tensorflow-core-generator/src/main/java/org/tensorflow/processor/operator/OperatorProcessor.java
+++ b/tensorflow-core/tensorflow-core-generator/src/main/java/org/tensorflow/processor/operator/OperatorProcessor.java
@@ -196,6 +196,8 @@ private static class OpsSpec {
       Pattern.compile("@(?:param|return|throws|exception|see|deprecated)\\s+.*");
   private static final TypeName T_OP = ClassName.get("org.tensorflow.op", "Op");
   private static final ClassName T_OPS = ClassName.get("org.tensorflow.op", "Ops");
+  private static final TypeName T_ITERABLE_OP =
+      ParameterizedTypeName.get(ClassName.get(Iterable.class), T_OP);
   private static final TypeName T_OPERATOR =
       ClassName.get("org.tensorflow.op.annotation", "Operator");
   private static final TypeName T_ENDPOINT =
@@ -205,13 +207,6 @@ private static class OpsSpec {
       ClassName.get("org.tensorflow", "ExecutionEnvironment");
   private static final TypeName T_EAGER_SESSION = ClassName.get("org.tensorflow", "EagerSession");
   private static final TypeName T_STRING = ClassName.get(String.class);
-  // Operand<?>
-  private static final TypeName T_OPERAND =
-      ParameterizedTypeName.get(
-          ClassName.get("org.tensorflow", "Operand"), WildcardTypeName.subtypeOf(Object.class));
-  // Iterable<Operand<?>>
-  private static final TypeName T_ITERABLE_OPERAND =
-      ParameterizedTypeName.get(ClassName.get(Iterable.class), T_OPERAND);
 
   private static final String LICENSE =
       "Copyright 2020 The TensorFlow Authors. All Rights Reserved.\n"
@@ -529,12 +524,12 @@ private static TypeSpec buildTopClass(OpsSpec spec) {
     opsBuilder.addMethod(
         MethodSpec.methodBuilder("withControlDependencies")
             .addModifiers(Modifier.PUBLIC)
-            .addParameter(T_ITERABLE_OPERAND, "controls")
+            .addParameter(T_ITERABLE_OP, "controls")
             .returns(T_OPS)
             .addStatement("return new Ops(scope.withControlDependencies(controls))")
             .addJavadoc(
                 "Returns an API that adds operations to the graph with the provided control dependencies.\n\n"
-                    + "@see {@link $T#withControlDependencies(Iterable<Operand<?>>)}\n",
+                    + "@see {@link $T#withControlDependencies(Iterable<Op<?>>)}\n",
                 T_SCOPE)
             .build());
 
diff --git a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaDelta.java b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaDelta.java
index b271993b974..e96eb7e557b 100644
--- a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaDelta.java
+++ b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaDelta.java
@@ -19,6 +19,7 @@
 import org.tensorflow.Graph;
 import org.tensorflow.Operand;
 import org.tensorflow.Output;
+import org.tensorflow.op.Op;
 import org.tensorflow.op.core.Variable;
 import org.tensorflow.types.family.TType;
 
@@ -77,7 +78,7 @@ private <T extends TType> void createAdaDeltaSlot(Output<T> v) {
   }
 
   @Override
-  protected <T extends TType> Operand<T> applyDense(Output<T> gradient, Output<T> variable) {
+  protected <T extends TType> Op applyDense(Output<T> gradient, Output<T> variable) {
     Variable<T> accumSlot = getSlot(variable, ACCUMULATOR).get();
     Variable<T> accumUpdateSlot = getSlot(variable, ACCUMULATOR_UPDATE).get();
     return tf.train.applyAdadelta(variable, accumSlot, accumUpdateSlot,
diff --git a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaGrad.java b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaGrad.java
index 541b60f4733..eeaa2b4be9b 100644
--- a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaGrad.java
+++ b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaGrad.java
@@ -19,6 +19,7 @@
 import org.tensorflow.Graph;
 import org.tensorflow.Operand;
 import org.tensorflow.Output;
+import org.tensorflow.op.Op;
 import org.tensorflow.op.core.Variable;
 import org.tensorflow.types.family.TType;
 
@@ -70,7 +71,7 @@ private <T extends TType> void createAdaGradSlot(Output<T> v) {
   }
 
   @Override
-  protected <T extends TType> Operand<T> applyDense(Output<T> gradient, Output<T> variable) {
+  protected <T extends TType> Op applyDense(Output<T> gradient, Output<T> variable) {
     Variable<T> slot = getSlot(variable, ACCUMULATOR).get();
     return tf.train
         .applyAdagrad(variable, slot, tf.dtypes.cast(tf.constant(learningRate), gradient.dataType()),
diff --git a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaGradDA.java b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaGradDA.java
index e4f0298537d..1f065a3a0ab 100644
--- a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaGradDA.java
+++ b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/AdaGradDA.java
@@ -69,7 +69,7 @@ public AdaGradDA(Graph graph, String name, float learningRate, float initialAccu
   }
 
   @Override
-  protected Optional<Operand<?>> prepare(String name) {
+  protected Optional<Op> prepare(String name) {
     return Optional.of(tf.assignAdd(globalStep, tf.constant(1L)));
   }
 
@@ -93,7 +93,7 @@ private <T extends TType> void createAdaGradDASlot(Output<T> v) {
   }
 
   @Override
-  protected <T extends TType> Operand<T> applyDense(Output<T> gradient, Output<T> variable) {
+  protected <T extends TType> Op applyDense(Output<T> gradient, Output<T> variable) {
     Variable<T> gradSlot = getSlot(variable, ACCUMULATOR).get();
     Variable<T> gradSquaredSlot = getSlot(variable, SQUARED_ACCUMULATOR).get();
     return tf.train.applyAdagradDa(variable, gradSlot, gradSquaredSlot, gradient,
@@ -113,7 +113,7 @@ protected <T extends TType> Operand<T> applyDense(Output<T> gradient, Output<T>
    * @return A NoOp with a control dependency on each update operation.
    */
   @Override
-  protected Op finish(List<Operand<?>> updateOperations, String name) {
+  protected Op finish(List<Op> updateOperations, String name) {
     updateOperations.add(tf.assignAdd(globalStep, tf.constant(1L)));
     return super.finish(updateOperations, name);
   }
diff --git a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Adam.java b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Adam.java
index 9ee87436e28..686ba411b48 100644
--- a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Adam.java
+++ b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Adam.java
@@ -118,7 +118,7 @@ protected void createSlots(List<Output<? extends TType>> variables) {
   }
 
   @Override
-  protected Optional<Operand<?>> prepare(String scopeName) {
+  protected Optional<Op> prepare(String scopeName) {
     betaOneConst = tf.constant(betaOne);
     betaTwoConst = tf.constant(betaTwo);
     learningRateConst = tf.constant(learningRate);
@@ -136,7 +136,7 @@ private <T extends TType> void createAdamSlot(Output<T> v) {
   }
 
   @Override
-  protected <T extends TType> Operand<T> applyDense(Output<T> gradient, Output<T> variable) {
+  protected <T extends TType> Op applyDense(Output<T> gradient, Output<T> variable) {
     Variable<T> firstMomentSlot = getSlot(variable, FIRST_MOMENT).get();
     Variable<T> secondMomentSlot = getSlot(variable, SECOND_MOMENT).get();
     return tf.train.applyAdam(variable, firstMomentSlot, secondMomentSlot,
@@ -159,7 +159,7 @@ protected <T extends TType> Operand<T> applyDense(Output<T> gradient, Output<T>
    * @return A NoOp with a control dependency on each update operation.
    */
   @Override
-  protected Op finish(List<Operand<?>> updateOperations, String name) {
+  protected Op finish(List<Op> updateOperations, String name) {
     updateOperations.add(tf.assign(betaOnePower, tf.math.mul(betaOnePower, betaOneConst)));
     updateOperations.add(tf.assign(betaTwoPower, tf.math.mul(betaTwoPower, betaTwoConst)));
     return super.finish(updateOperations, name);
diff --git a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/GradientDescent.java b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/GradientDescent.java
index f6890e711f8..e0ef11421a8 100644
--- a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/GradientDescent.java
+++ b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/GradientDescent.java
@@ -16,8 +16,8 @@
 package org.tensorflow.training.optimizers;
 
 import org.tensorflow.Graph;
-import org.tensorflow.Operand;
 import org.tensorflow.Output;
+import org.tensorflow.op.Op;
 import org.tensorflow.types.family.TType;
 
 /**
@@ -38,7 +38,7 @@ public GradientDescent(Graph graph, String name, float learningRate) {
   }
 
   @Override
-  protected <T extends TType> Operand<T> applyDense(Output<T> gradient, Output<T> variable) {
+  protected <T extends TType> Op applyDense(Output<T> gradient, Output<T> variable) {
     return tf.train.applyGradientDescent(variable,
         tf.dtypes.cast(tf.constant(learningRate), gradient.dataType()), gradient);
   }
diff --git a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Momentum.java b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Momentum.java
index 98d69451330..e5aa51e1c32 100644
--- a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Momentum.java
+++ b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Momentum.java
@@ -19,6 +19,7 @@
 import org.tensorflow.Graph;
 import org.tensorflow.Operand;
 import org.tensorflow.Output;
+import org.tensorflow.op.Op;
 import org.tensorflow.op.core.Variable;
 import org.tensorflow.op.train.ApplyMomentum;
 import org.tensorflow.types.family.TType;
@@ -67,7 +68,7 @@ private <T extends TType> void createMomentumSlot(Output<T> v) {
   }
 
   @Override
-  protected <T extends TType> Operand<T> applyDense(Output<T> gradient, Output<T> variable) {
+  protected <T extends TType> Op applyDense(Output<T> gradient, Output<T> variable) {
     Variable<T> slot = getSlot(variable, MOMENTUM).get();
     return tf.train
         .applyMomentum(variable, slot, tf.dtypes.cast(tf.constant(learningRate), gradient.dataType()),
diff --git a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Optimizer.java b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Optimizer.java
index fc540f43ffc..a6c3bb5244e 100644
--- a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Optimizer.java
+++ b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/Optimizer.java
@@ -130,9 +130,9 @@ public Op applyGradients(List<GradAndVar<? extends TType>> gradsAndVars, String
 
     createSlots(variables);
 
-    Optional<Operand<? extends TType>> prepOp = prepare(name + "/prepare");
+    Optional<Op> prepOp = prepare(name + "/prepare");
 
-    List<Operand<? extends TType>> updateOps = new ArrayList<>();
+    List<Op> updateOps = new ArrayList<>();
     prepOp.ifPresent(updateOps::add);
     for (GradAndVar<? extends TType> pair : gradsAndVars) {
       updateOps.add(applyDense(pair));
@@ -199,7 +199,7 @@ protected <T extends TType> void createSlot(Output<T> variable, String slotName,
    *
    * @param scopeName The scope name to use for any variable creations.
    */
-  protected Optional<Operand<? extends TType>> prepare(String scopeName) {
+  protected Optional<Op> prepare(String scopeName) {
     return Optional.empty();
   }
 
@@ -211,7 +211,7 @@ protected Optional<Operand<? extends TType>> prepare(String scopeName) {
   protected void createSlots(List<Output<? extends TType>> variables) {
   }
 
-  private <T extends TType> Operand<T> applyDense(GradAndVar<T> gradVarPair) {
+  private <T extends TType> Op applyDense(GradAndVar<T> gradVarPair) {
     return applyDense(gradVarPair.getGradient(), gradVarPair.getVariable());
   }
 
@@ -223,8 +223,7 @@ private <T extends TType> Operand<T> applyDense(GradAndVar<T> gradVarPair) {
    * @param <T>      The type of the variable.
    * @return An operand which applies the desired optimizer update to the variable.
    */
-  protected abstract <T extends TType> Operand<T> applyDense(Output<T> gradient,
-      Output<T> variable);
+  protected abstract <T extends TType> Op applyDense(Output<T> gradient, Output<T> variable);
 
   /**
    * Gathers up the update operations into a single op that can be used as a run target.
@@ -233,7 +232,7 @@ protected abstract <T extends TType> Operand<T> applyDense(Output<T> gradient,
    * @param name             The name of the run target.
    * @return A NoOp with a control dependency on each update operation.
    */
-  protected Op finish(List<Operand<?>> updateOperations, String name) {
+  protected Op finish(List<Op> updateOperations, String name) {
     Scope scope = new Scope(graph);
     scope = scope.withName(name);
     scope = scope.withControlDependencies(updateOperations);
diff --git a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/RMSProp.java b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/RMSProp.java
index 4e7bf66f37a..8e1a2f813c1 100644
--- a/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/RMSProp.java
+++ b/tensorflow-training/src/main/java/org/tensorflow/training/optimizers/RMSProp.java
@@ -19,6 +19,7 @@
 import org.tensorflow.Graph;
 import org.tensorflow.Operand;
 import org.tensorflow.Output;
+import org.tensorflow.op.Op;
 import org.tensorflow.op.core.Variable;
 import org.tensorflow.types.family.TType;
 
@@ -90,7 +91,7 @@ private <T extends TType> void createRMSPropSlot(Output<T> v) {
   }
 
   @Override
-  protected <T extends TType> Operand<T> applyDense(Output<T> gradient, Output<T> variable) {
+  protected <T extends TType> Op applyDense(Output<T> gradient, Output<T> variable) {
     Variable<T> rmsSlot = getSlot(variable, RMS).get();
     Variable<T> momentumSlot = getSlot(variable, MOMENTUM).get();
     if (centered) {

From 13cdae07119869df0fd77d0b91b259465ae87313 Mon Sep 17 00:00:00 2001
From: Karl Lessard <karl.lessard@gmail.com>
Date: Sat, 28 Mar 2020 19:00:56 -0400
Subject: [PATCH 3/7] Execute graph initializers in a single call

---
 .../annotations/org/tensorflow/op/Ops.java    |  34 ++++++
 .../src/main/java/org/tensorflow/Graph.java   |  18 +---
 .../src/main/java/org/tensorflow/Session.java | 102 ++++++++++++++++++
 .../java/org/tensorflow/op/core/Helpers.java  |  17 +--
 .../java/org/tensorflow/op/core/Init.java     |  68 ++++++++++++
 .../test/java/org/tensorflow/SessionTest.java |  72 +++++++++++++
 .../processor/operator/OperatorProcessor.java |   7 +-
 7 files changed, 290 insertions(+), 28 deletions(-)
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Init.java

diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/Ops.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/Ops.java
index 850bf316db6..2025427ce1b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/Ops.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/Ops.java
@@ -79,6 +79,7 @@
 import org.tensorflow.op.core.Identity;
 import org.tensorflow.op.core.IdentityN;
 import org.tensorflow.op.core.ImmutableConst;
+import org.tensorflow.op.core.Init;
 import org.tensorflow.op.core.InitializeTable;
 import org.tensorflow.op.core.InitializeTableFromTextFile;
 import org.tensorflow.op.core.InplaceAdd;
@@ -2660,6 +2661,39 @@ public <T extends TType> ImmutableConst<T> immutableConst(DataType<T> dtype, Sha
     return ImmutableConst.create(scope, dtype, shape, memoryRegionName);
   }
 
+  /**
+   * Factory method to create an operation executing all initializers of a graph.
+   *
+   *  <p>All initializers added to a graph via {@link #add(Scope, Op) tf.initAdd} are grouped
+   *  together as a single unit of computation in the graph.
+   *
+   *  <p>This op must be added to all graphs using one or more {@link Variable variables} and must be
+   *  run prior to training using {@link org.tensorflow.Session#runInit() Session.runInit()} in order
+   *  to initialize the variables state.</p>
+   *
+   * @param scope current scope
+   * @return an op grouping all initializers added to the graph
+   * @throws IllegalArgumentException if the execution environment in scope is not a graph
+   */
+  public Init init() {
+    return Init.create(scope);
+  }
+
+  /**
+   * Register an op as an initializer of the graph.
+   *
+   *  <p>The op will be registered to be invoked when the {@link #create(Scope) init} op is executed
+   *  by a graph session prior to training using {@link org.tensorflow.Session#runInit() Session.runInit()}
+   *
+   * @param scope
+   * @param initializer
+   * @throws IllegalArgumentException if the execution environment in scope is not a graph
+   * @see #create(Scope)
+   */
+  public void initAdd(Op initializer) {
+    Init.add(scope, initializer);
+  }
+
   /**
    * Table initializer that takes two tensors for keys and values respectively.
    *
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Graph.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Graph.java
index 041befd4d26..7631b0b2b33 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Graph.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Graph.java
@@ -27,6 +27,7 @@
 import static org.tensorflow.internal.c_api.global.tensorflow.TF_NewWhile;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 import org.bytedeco.javacpp.BytePointer;
@@ -41,8 +42,6 @@
 import org.tensorflow.internal.c_api.TF_Status;
 import org.tensorflow.internal.c_api.TF_WhileParams;
 import org.tensorflow.op.Op;
-import org.tensorflow.op.Scope;
-import org.tensorflow.op.core.NoOp;
 
 
 /**
@@ -55,8 +54,6 @@
  */
 public final class Graph implements ExecutionEnvironment, AutoCloseable {
 
-  public static final String DEFAULT_INIT_NAME = "init";
-
   /** Create an empty Graph. */
   public Graph() {
     nativeHandle = allocate();
@@ -183,17 +180,10 @@ public synchronized void addInitializer(Op initializer) {
   }
 
   /**
-   * Returns an op which initializers all the variables.
-   * @return The initializer operation.
+   * Returns all initializers added to the graph via {@link #addInitializer(Op)}
    */
-  public NoOp variablesInitializer() {
-    return variablesInitializer(DEFAULT_INIT_NAME);
-  }
-
-  public NoOp variablesInitializer(String name) {
-    Scope scope = new Scope(this);
-    scope = scope.withName(name).withControlDependencies(initializers);
-    return NoOp.create(scope);
+  public List<Op> initializers() {
+    return Collections.unmodifiableList(initializers);
   }
 
   /**
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Session.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Session.java
index 118ce92f456..005a34a408c 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Session.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Session.java
@@ -36,6 +36,8 @@
 import org.tensorflow.internal.c_api.TF_SessionOptions;
 import org.tensorflow.internal.c_api.TF_Status;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.op.Op;
+import org.tensorflow.op.core.Init;
 
 /**
  * Driver for {@link Graph} execution.
@@ -432,6 +434,106 @@ public Runner runner() {
     return new Runner();
   }
 
+  /**
+   * Run all graph initializers.
+   *
+   * <p>Initializers must be executed once before running the graph in a training
+   * loop using a session {@link Runner}.</p>
+   *
+   * <p>This method invokes {@link #runInit(String)} using the default name for the init
+   * operation, which is {@link Init#DEFAULT_NAME}. For example:</p>
+   * <pre>{@code
+   * try (Graph g = new Graph()) {
+   *   Ops tf = Ops.create(g);
+   *
+   *   Variable<TInt32> x = tf.variable(tf.constant(10));
+   *   Variable<TInt32> y = tf.variable(tf.constant(20));
+   *   Add<TInt32> z = tf.math.add(x, y);
+   *   tf.init();
+   *
+   *   try (Session s = new Session(g)) {
+   *     s.runInit();
+   *
+   *     try (Tensor<TInt32> t = s.runner().fetch(z).run().get(0).expect(TInt32.DTYPE)) {
+   *       assertEquals(30, t.data().getInt());
+   *     }
+   *   }
+   * }
+   * }</pre>
+   */
+  public void runInit() {
+    runInit(Init.DEFAULT_NAME);
+  }
+
+  /**
+   * Run all graph initializers grouped under the {@code initOpName} operation.
+   *
+   * <p>Initializers must be executed once before running the graph in a training loop using a
+   * session {@link Runner}.</p>
+   *
+   * <p>The {@code initOpName} is the name of a single operation already added to the
+   * graph that executes all graph initializers at once. For example:</p>
+   * <pre>{@code
+   * try (Graph g = new Graph()) {
+   *   Ops tf = Ops.create(g);
+   *
+   *   Variable<TInt32> x = tf.variable(tf.constant(10));
+   *   Variable<TInt32> y = tf.variable(tf.constant(20));
+   *   Add<TInt32> z = tf.math.add(x, y);
+   *   tf.withName("initialize").init();
+   *
+   *   try (Session s = new Session(g)) {
+   *     s.runInit("initialize");
+   *
+   *     try (Tensor<TInt32> t = s.runner().fetch(z).run().get(0).expect(TInt32.DTYPE)) {
+   *       assertEquals(30, t.data().getInt());
+   *     }
+   *   }
+   * }
+   * }</pre>
+   *
+   * @param initOpName name of the initializer operation.
+   */
+  public void runInit(String initOpName) {
+    Operation operation = graph.operation(initOpName);
+    if (operation == null) {
+      throw new IllegalArgumentException("Initializer operation named '"
+          + initOpName + "' cannot be found in the graph");
+    }
+    runner().addTarget(operation).run();
+  }
+
+  /**
+   * Run all graph initializers registered by the given {@code init} op.
+   *
+   * <p>Initializers must be executed once before running the graph in a training
+   * loop using a session {@link Runner}.</p>
+   *
+   * <p>This method can be used if the graph is being built by the same program running the session.
+   * For example:</p>
+   * <pre>{@code
+   * try (Graph g = new Graph()) {
+   *   Ops tf = Ops.create(g);
+   *
+   *   Variable<TInt32> x = tf.variable(tf.constant(10));
+   *   Variable<TInt32> y = tf.variable(tf.constant(20));
+   *   Add<TInt32> z = tf.math.add(x, y);
+   *   Init init = tf.withName("initialize").init();
+   *
+   *   try (Session s = new Session(g)) {
+   *     s.runInit(init);
+   *
+   *     try (Tensor<TInt32> t = s.runner().fetch(z).run().get(0).expect(TInt32.DTYPE)) {
+   *       assertEquals(30, t.data().getInt());
+   *     }
+   *   }
+   * }
+   * }</pre>
+   */
+  public void runInit(Init initOp) {
+    runner().addTarget(initOp.op()).run();
+  }
+
   /**
    * Output tensors and metadata obtained when executing a session.
    *
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Helpers.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Helpers.java
index 170fef6eb0e..f9ce837fe60 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Helpers.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Helpers.java
@@ -15,8 +15,6 @@
  */
 package org.tensorflow.op.core;
 
-import org.tensorflow.ExecutionEnvironment;
-import org.tensorflow.Graph;
 import org.tensorflow.Operand;
 import org.tensorflow.Output;
 import org.tensorflow.op.Scope;
@@ -46,19 +44,12 @@ private Helpers() {}
      * @param options carries optional attributes values
      * @return a new instance of Variable
      */
-    @Endpoint(name="variable")
+    @Endpoint(name = "variable")
     public static <T extends TType> Variable<T> createVariableWithInit(Scope scope, Operand<T> init, Variable.Options... options) {
         Output<T> initOutput = init.asOutput();
-        Variable<T> newVar = Variable.create(scope,initOutput.shape(),initOutput.dataType(),options);
-        Assign<T> assignOp = Assign.create(scope,newVar,init);
-        ExecutionEnvironment exEnv = scope.env();
-        if (exEnv instanceof Graph) {
-            Graph graph = (Graph) exEnv;
-            graph.addInitializer(assignOp);
-        } else {
-            throw new IllegalArgumentException("variable with init is only supported on Graph sessions.");
-        }
-
+        Variable<T> newVar = Variable.create(scope,initOutput.shape(), initOutput.dataType(), options);
+        Assign<T> assignOp = Assign.create(scope, newVar, init);
+        Init.add(scope, assignOp);
         return newVar;
     }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Init.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Init.java
new file mode 100644
index 00000000000..f8eb4b793f0
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Init.java
@@ -0,0 +1,68 @@
+package org.tensorflow.op.core;
+
+import org.tensorflow.ExecutionEnvironment;
+import org.tensorflow.Graph;
+import org.tensorflow.Operation;
+import org.tensorflow.OperationBuilder;
+import org.tensorflow.op.Op;
+import org.tensorflow.op.RawOp;
+import org.tensorflow.op.Scope;
+import org.tensorflow.op.annotation.Endpoint;
+import org.tensorflow.op.annotation.Operator;
+
+@Operator
+public final class Init extends RawOp {
+
+  public static final String DEFAULT_NAME = "init";
+
+  /**
+   * Factory method to create an operation executing all initializers of a graph.
+   *
+   * <p>All initializers added to a graph via {@link #add(Scope, Op) tf.initAdd} are grouped
+   * together as a single unit of computation in the graph.
+   *
+   * <p>This op must be added to all graphs using one or more {@link Variable variables} and must be
+   * run prior to training using {@link org.tensorflow.Session#runInit() Session.runInit()} in order
+   * to initialize the variables state.</p>
+   *
+   * @param scope current scope
+   * @return an op grouping all initializers added to the graph
+   * @throws IllegalArgumentException if the execution environment in scope is not a graph
+   */
+  @Endpoint(name = "init")
+  public static Init create(Scope scope) {
+    ExecutionEnvironment exEnv = scope.env();
+    if (!(exEnv instanceof Graph)) {
+      throw new IllegalArgumentException("init is only supported on Graph sessions.");
+    }
+    Graph graph = (Graph)exEnv;
+    OperationBuilder opBuilder = scope.env().opBuilder("NoOp", scope.makeOpName(DEFAULT_NAME));
+    scope.withControlDependencies(graph.initializers()).applyControlDependencies(opBuilder);
+    return new Init(opBuilder.build());
+  }
+
+  /**
+   * Register an op as an initializer of the graph.
+   *
+   * <p>The op will be registered to be invoked when the {@link #create(Scope) init} op is executed
+   * by a graph session prior to training using {@link org.tensorflow.Session#runInit() Session.runInit()}
+   *
+   * @param scope
+   * @param initializer
+   * @throws IllegalArgumentException if the execution environment in scope is not a graph
+   * @see #create(Scope)
+   */
+  @Endpoint(name = "initAdd")
+  public static void add(Scope scope, Op initializer) {
+    ExecutionEnvironment exEnv = scope.env();
+    if (!(exEnv instanceof Graph)) {
+      throw new IllegalArgumentException("initAdd is only supported on Graph sessions.");
+    }
+    Graph graph = (Graph) exEnv;
+    graph.addInitializer(initializer);
+  }
+
+  private Init(Operation operation) {
+    super(operation);
+  }
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/SessionTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/SessionTest.java
index 0e5d499f4dc..43145e8b97e 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/SessionTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/SessionTest.java
@@ -23,8 +23,11 @@
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.tensorflow.op.Ops;
+import org.tensorflow.op.core.Init;
 import org.tensorflow.op.core.Split;
+import org.tensorflow.op.core.Variable;
 import org.tensorflow.op.linalg.MatMul;
+import org.tensorflow.op.math.Add;
 import org.tensorflow.tools.Shape;
 import org.tensorflow.tools.ndarray.NdArrays;
 import org.tensorflow.tools.ndarray.StdArrays;
@@ -161,6 +164,75 @@ public void createWithConfigProto() {
         Session s = new Session(g, singleThreadConfigProto())) {}
   }
 
+  @Test
+  public void runInit() {
+    try (Graph g = new Graph()) {
+      Ops tf = Ops.create(g);
+
+      Variable<TInt32> var1 = tf.variable(Shape.scalar(), TInt32.DTYPE);
+      tf.initAdd(tf.assign(var1, tf.constant(10)));
+      Variable<TInt32> var2 = tf.variable(tf.constant(20));
+      Add<TInt32> add = tf.math.add(var1, var2);
+      tf.init();
+
+      try (Session s = new Session(g)) {
+        s.runInit();
+
+        try (Tensor<TInt32> t = s.runner().fetch(add).run().get(0).expect(TInt32.DTYPE)) {
+          assertEquals(30, t.data().getInt());
+        }
+      }
+    }
+  }
+
+  @Test
+  public void runInitByVar() {
+    try (Graph g = new Graph()) {
+      Ops tf = Ops.create(g);
+
+      Variable<TInt32> var1 = tf.variable(Shape.scalar(), TInt32.DTYPE);
+      tf.initAdd(tf.assign(var1, tf.constant(10)));
+      Variable<TInt32> var2 = tf.variable(tf.constant(20));
+      Add<TInt32> add = tf.math.add(var1, var2);
+      Init init = tf.withName("initialize").init();
+
+      try (Session s = new Session(g)) {
+        s.runInit(init);
+
+        try (Tensor<TInt32> t = s.runner().fetch(add).run().get(0).expect(TInt32.DTYPE)) {
+          assertEquals(30, t.data().getInt());
+        }
+      }
+    }
+  }
+
+  @Test
+  public void runInitByName() {
+    try (Graph g = new Graph()) {
+      Ops tf = Ops.create(g);
+
+      Variable<TInt32> var1 = tf.variable(Shape.scalar(), TInt32.DTYPE);
+      tf.initAdd(tf.assign(var1, tf.constant(10)));
+      Variable<TInt32> var2 = tf.variable(tf.constant(20));
+      Add<TInt32> add = tf.math.add(var1, var2);
+      tf.withName("init_test").init();
+
+      try (Session s = new Session(g)) {
+        s.runInit("init_test");
+
+        try (Tensor<TInt32> t = s.runner().fetch(add).run().get(0).expect(TInt32.DTYPE)) {
+          assertEquals(30, t.data().getInt());
+        }
+        try {
+          s.runInit("wrong_name");
+          fail();
+        } catch (IllegalArgumentException e) {
+          // as expected
+        }
+      }
+    }
+  }
+
   private static byte[] fullTraceRunOptions() {
     // Ideally this would use the generated Java sources for protocol buffers
     // and end up with something like the snippet below. However, generating
diff --git a/tensorflow-core/tensorflow-core-generator/src/main/java/org/tensorflow/processor/operator/OperatorProcessor.java b/tensorflow-core/tensorflow-core-generator/src/main/java/org/tensorflow/processor/operator/OperatorProcessor.java
index 4986d3c63a9..1c750fbecce 100644
--- a/tensorflow-core/tensorflow-core-generator/src/main/java/org/tensorflow/processor/operator/OperatorProcessor.java
+++ b/tensorflow-core/tensorflow-core-generator/src/main/java/org/tensorflow/processor/operator/OperatorProcessor.java
@@ -58,6 +58,7 @@
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.element.TypeParameterElement;
 import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.NoType;
 import javax.lang.model.type.TypeMirror;
 import javax.lang.model.type.TypeVariable;
 import javax.lang.model.util.ElementFilter;
@@ -350,7 +351,11 @@ private MethodSpec buildOpMethod(
     for (TypeMirror thrownType : endpointMethod.getThrownTypes()) {
       builder.addException(TypeName.get(thrownType));
     }
-    StringBuilder call = new StringBuilder("return $T.")
+    StringBuilder call = new StringBuilder();
+    if (!NoType.class.isAssignableFrom(endpointMethod.getReturnType().getClass())) {
+      call.append("return ");
+    }
+    call.append("$T.")
       .append(endpointMethod.getSimpleName())
       .append("(scope");
     boolean first = true;

From 98fb67b811249889d22d5dd47917206c0969bae5 Mon Sep 17 00:00:00 2001
From: Karl Lessard <karl.lessard@gmail.com>
Date: Sun, 29 Mar 2020 17:08:29 -0400
Subject: [PATCH 4/7] Add an Op as a target

---
 .../src/main/java/org/tensorflow/Session.java               | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Session.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Session.java
index 005a34a408c..cdad0804097 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Session.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Session.java
@@ -252,11 +252,11 @@ public Runner addTarget(Operation operation) {
     }
 
     /**
-     * Make {@link #run} execute {@code operand}, but not return any evaluated {@link Tensor
+     * Make {@link #run} execute {@code op}, but not return any evaluated {@link Tensor
      * Tensors}.
      */
-    public Runner addTarget(Operand<?> operand) {
-      return addTarget(operand.asOutput().op());
+    public Runner addTarget(Op op) {
+      return addTarget(op.op());
     }
 
     /**

From 0f48e827e03bbd04bbd3b365c44906b94eee6c2c Mon Sep 17 00:00:00 2001
From: Karl Lessard <karl.lessard@gmail.com>
Date: Thu, 2 Apr 2020 23:58:20 -0400
Subject: [PATCH 5/7] Run any single op from session

---
 .../annotations/org/tensorflow/op/Ops.java    | 60 ++++++++++--
 .../src/main/java/org/tensorflow/Session.java | 96 +++----------------
 .../java/org/tensorflow/op/core/Init.java     | 60 ++++++++++--
 .../test/java/org/tensorflow/SessionTest.java | 29 +-----
 4 files changed, 119 insertions(+), 126 deletions(-)

diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/Ops.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/Ops.java
index 2025427ce1b..f0f1a4074b8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/Ops.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/Ops.java
@@ -2664,12 +2664,55 @@ public <T extends TType> ImmutableConst<T> immutableConst(DataType<T> dtype, Sha
   /**
    * Factory method to create an operation executing all initializers of a graph.
    *
-   *  <p>All initializers added to a graph via {@link #add(Scope, Op) tf.initAdd} are grouped
-   *  together as a single unit of computation in the graph.
+   *  <p>All initializers added to a graph via
+   *  {@link org.tensorflow.op.core.Init#add(Scope, Op) tf.initAdd} are grouped together as a single
+   *  unit of computation in the graph. This operation must then be added to any graph using one or
+   *  more {@link Variable variables} and executed once before running the graph so the variable
+   *  states are initialized properly.</p>
+   *
+   *  <p>When the graph is built by the same process that is running the session, the initializers
+   *  can be invoked by executing this single endpoint. For example:</p>
+   *  <pre>{@code
+   *  try (Graph g = new Graph()) {
+   *    Variable<TInt32> x = tf.variable(tf.constant(10));  // initAdd is called implicitly
+   *    Variable<TInt32> y = tf.variable(tf.constant(20));  // idem
+   *    Add<TInt32> z = tf.math.add(x, y);
+   *
+   *    try (Session s = new Session(g)) {
+   *      s.run(tf.init());  // initialize all variables
+   *
+   *      try (Tensor<TInt32> t = s.runner().fetch(z).run().get(0).expect(TInt32.DTYPE)) {
+   *        assertEquals(30, t.data().getInt());
+   *      }
+   *    }
+   *  }
+   *  }</pre>
    *
-   *  <p>This op must be added to all graphs using one or more {@link Variable variables} and must be
-   *  run prior to training using {@link org.tensorflow.Session#runInit() Session.runInit()} in order
-   *  to initialize the variables state.</p>
+   *  <p>When the graph is built by a separate process, the initializers can be invoked by running
+   *  the init op by its name, which defaults to {@link org.tensorflow.op.core.Init#DEFAULT_NAME}.
+   *  For example:</p>
+   *  <pre>{@code
+   *  // Building the model
+   *  try (Graph g = new Graph()) {
+   *    Variable<TInt32> x = tf.variable(tf.constant(10));  // initAdd is called implicitly
+   *    Variable<TInt32> y = tf.variable(tf.constant(20));  // idem
+   *    Add<TInt32> z = tf.withName("z").math.add(x, y);
+   *
+   *    tf.init();  // add variables initializers to the graph, as Init.DEFAULT_NAME
+   *    // ...exporting graph as a saved model...
+   *  }
+   *
+   *  ...
+   *
+   *  // Running the model
+   *  try (SavedModelBundle model = SavedModelBundle.load("/path/to/model", "train")) {
+   *    model.session().run(Init.DEFAULT_NAME);
+   *
+   *    try (Tensor<TInt32> t = s.runner().fetch("z").run().get(0).expect(TInt32.DTYPE)) {
+   *      assertEquals(30, t.data().getInt());
+   *    }
+   *  }
+   *  }</pre>
    *
    * @param scope current scope
    * @return an op grouping all initializers added to the graph
@@ -2682,13 +2725,14 @@ public Init init() {
   /**
    * Register an op as an initializer of the graph.
    *
-   *  <p>The op will be registered to be invoked when the {@link #create(Scope) init} op is executed
-   *  by a graph session prior to training using {@link org.tensorflow.Session#runInit() Session.runInit()}
+   *  <p>Registered initializers are then grouped as a single unit of computation by adding
+   *  and executing an {@link org.tensorflow.op.core.Init#create(Scope) init} operation from a graph
+   *  session.
    *
    * @param scope
    * @param initializer
    * @throws IllegalArgumentException if the execution environment in scope is not a graph
-   * @see #create(Scope)
+   * @see org.tensorflow.op.core.Init#create(Scope) init
    */
   public void initAdd(Op initializer) {
     Init.add(scope, initializer);
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Session.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Session.java
index cdad0804097..fc80fe529ba 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Session.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Session.java
@@ -435,103 +435,31 @@ public Runner runner() {
   }
 
   /**
-   * Run all graph initializers.
+   * Executes an operation in the graph with the given name.
    *
-   * <p>Initializers must be executed once before running the graph in a training
-   * loop using a session {@link Runner}.</p>
+   * <p>This method is equivalent to {@code session.runner().addTarget(opName).run()}.</p>
    *
-   * <p>This method invokes {@link #runInit(String)} using the default name for the init
-   * operation, which is {@link Init#DEFAULT_NAME}. For example:</p>
-   * <pre>{@code
-   * try (Graph g = new Graph()) {
-   *   Ops tf = Ops.create(g);
-   *
-   *   Variable<TInt32> x = tf.variable(tf.constant(10));
-   *   Variable<TInt32> y = tf.variable(tf.constant(20));
-   *   Add<TInt32> z = tf.math.add(x, y);
-   *   tf.init();
-   *
-   *   try (Session s = new Session(g)) {
-   *     s.runInit();
-   *
-   *     try (Tensor<TInt32> t = s.runner().fetch(z).run().get(0).expect(TInt32.DTYPE)) {
-   *       assertEquals(30, t.data().getInt());
-   *     }
-   *   }
-   * }
-   * }</pre>
-   */
-  public void runInit() {
-    runInit(Init.DEFAULT_NAME);
-  }
-
-  /**
-   * Run all graph initializers grouped under the {@code initOpName} operation.
-   *
-   * <p>Initializers must be executed once before running the graph in a training loop using a
-   * session {@link Runner}.</p>
-   *
-   * <p>The {@code initOpName} is the name of a single operation already added to the
-   * graph that executes all graph initializers at once. For example:</p>
-   * <pre>{@code
-   * try (Graph g = new Graph()) {
-   *   Ops tf = Ops.create(g);
-   *
-   *   Variable<TInt32> x = tf.variable(tf.constant(10));
-   *   Variable<TInt32> y = tf.variable(tf.constant(20));
-   *   Add<TInt32> z = tf.math.add(x, y);
-   *   tf.withName("initialize").init();
-   *
-   *   try (Session s = new Session(g)) {
-   *     s.runInit("initialize");
-   *
-   *     try (Tensor<TInt32> t = s.runner().fetch(z).run().get(0).expect(TInt32.DTYPE)) {
-   *       assertEquals(30, t.data().getInt());
-   *     }
-   *   }
-   * }
-   * }</pre>
-   *
-   * @param initOpName name of the initializer operation.
+   * @param opName name of the operation to run.
+   * @throws IllegalArgumentException if no operation of that name can be found in the graph
    */
-  public void runInit(String initOpName) {
-    Operation operation = graph.operation(initOpName);
+  public void run(String opName) {
+    Operation operation = graph.operation(opName);
     if (operation == null) {
       throw new IllegalArgumentException("Initializer operation named '"
-          + initOpName + "' cannot be found in the graph");
+          + opName + "' cannot be found in the graph");
     }
     runner().addTarget(operation).run();
   }
 
   /**
-   * Run all graph initializers registered by the given {@code init} op.
-   *
-   * <p>Initializers must be executed once before running the graph in a training
-   * loop using a session {@link Runner}.</p>
-   *
-   * <p>This method can be used if the graph is being built by the same program running the session.
-   * For example:</p>
-   * <pre>{@code
-   * try (Graph g = new Graph()) {
-   *   Ops tf = Ops.create(g);
-   *
-   *   Variable<TInt32> x = tf.variable(tf.constant(10));
-   *   Variable<TInt32> y = tf.variable(tf.constant(20));
-   *   Add<TInt32> z = tf.math.add(x, y);
-   *   Init init = tf.withName("initialize").init();
+   * Executes an operation in the graph.
    *
-   *   try (Session s = new Session(g)) {
-   *     s.runInit(init);
+   * <p>This method is equivalent to {@code session.runner().addTarget(op).run()}.</p>
    *
-   *     try (Tensor<TInt32> t = s.runner().fetch(z).run().get(0).expect(TInt32.DTYPE)) {
-   *       assertEquals(30, t.data().getInt());
-   *     }
-   *   }
-   * }
-   * }</pre>
+   * @param op the operation to run.
    */
-  public void runInit(Init initOp) {
-    runner().addTarget(initOp.op()).run();
+  public void run(Op op) {
+    runner().addTarget(op.op()).run();
   }
 
   /**
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Init.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Init.java
index f8eb4b793f0..e0f64b6b19a 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Init.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Init.java
@@ -18,12 +18,55 @@ public final class Init extends RawOp {
   /**
    * Factory method to create an operation executing all initializers of a graph.
    *
-   * <p>All initializers added to a graph via {@link #add(Scope, Op) tf.initAdd} are grouped
-   * together as a single unit of computation in the graph.
+   * <p>All initializers added to a graph via
+   * {@link org.tensorflow.op.core.Init#add(Scope, Op) tf.initAdd} are grouped together as a single
+   * unit of computation in the graph. This operation must then be added to any graph using one or
+   * more {@link Variable variables} and executed once before running the graph so the variable
+   * states are initialized properly.</p>
    *
-   * <p>This op must be added to all graphs using one or more {@link Variable variables} and must be
-   * run prior to training using {@link org.tensorflow.Session#runInit() Session.runInit()} in order
-   * to initialize the variables state.</p>
+   * <p>When the graph is built by the same process that is running the session, the initializers
+   * can be invoked by executing this single endpoint. For example:</p>
+   * <pre>{@code
+   * try (Graph g = new Graph()) {
+   *   Variable<TInt32> x = tf.variable(tf.constant(10));  // initAdd is called implicitly
+   *   Variable<TInt32> y = tf.variable(tf.constant(20));  // idem
+   *   Add<TInt32> z = tf.math.add(x, y);
+   *
+   *   try (Session s = new Session(g)) {
+   *     s.run(tf.init());  // initialize all variables
+   *
+   *     try (Tensor<TInt32> t = s.runner().fetch(z).run().get(0).expect(TInt32.DTYPE)) {
+   *       assertEquals(30, t.data().getInt());
+   *     }
+   *   }
+   * }
+   * }</pre>
+   *
+   * <p>When the graph is built by a separate process, the initializers can be invoked by running
+   * the init op by its name, which defaults to {@link org.tensorflow.op.core.Init#DEFAULT_NAME}.
+   * For example:</p>
+   * <pre>{@code
+   * // Building the model
+   * try (Graph g = new Graph()) {
+   *   Variable<TInt32> x = tf.variable(tf.constant(10));  // initAdd is called implicitly
+   *   Variable<TInt32> y = tf.variable(tf.constant(20));  // idem
+   *   Add<TInt32> z = tf.withName("z").math.add(x, y);
+   *
+   *   tf.init();  // add variables initializers to the graph, as Init.DEFAULT_NAME
+   *   // ...exporting graph as a saved model...
+   * }
+   *
+   * ...
+   *
+   * // Running the model
+   * try (SavedModelBundle model = SavedModelBundle.load("/path/to/model", "train")) {
+   *   model.session().run(Init.DEFAULT_NAME);
+   *
+   *   try (Tensor<TInt32> t = s.runner().fetch("z").run().get(0).expect(TInt32.DTYPE)) {
+   *     assertEquals(30, t.data().getInt());
+   *   }
+   * }
+   * }</pre>
    *
    * @param scope current scope
    * @return an op grouping all initializers added to the graph
@@ -44,13 +87,14 @@ public static Init create(Scope scope) {
   /**
    * Register an op as an initializer of the graph.
    *
-   * <p>The op will be registered to be invoked when the {@link #create(Scope) init} op is executed
-   * by a graph session prior to training using {@link org.tensorflow.Session#runInit() Session.runInit()}
+   * <p>Registered initializers are then grouped as a single unit of computation by adding
+   * and executing an {@link org.tensorflow.op.core.Init#create(Scope) init} operation from a graph
+   * session.
    *
    * @param scope
    * @param initializer
    * @throws IllegalArgumentException if the execution environment in scope is not a graph
-   * @see #create(Scope)
+   * @see org.tensorflow.op.core.Init#create(Scope) init
    */
   @Endpoint(name = "initAdd")
   public static void add(Scope scope, Op initializer) {
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/SessionTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/SessionTest.java
index 43145e8b97e..c0446ea3cd4 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/SessionTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/SessionTest.java
@@ -23,7 +23,6 @@
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.tensorflow.op.Ops;
-import org.tensorflow.op.core.Init;
 import org.tensorflow.op.core.Split;
 import org.tensorflow.op.core.Variable;
 import org.tensorflow.op.linalg.MatMul;
@@ -173,31 +172,9 @@ public void runInit() {
       tf.initAdd(tf.assign(var1, tf.constant(10)));
       Variable<TInt32> var2 = tf.variable(tf.constant(20));
       Add<TInt32> add = tf.math.add(var1, var2);
-      tf.init();
 
       try (Session s = new Session(g)) {
-        s.runInit();
-
-        try (Tensor<TInt32> t = s.runner().fetch(add).run().get(0).expect(TInt32.DTYPE)) {
-          assertEquals(30, t.data().getInt());
-        }
-      }
-    }
-  }
-
-  @Test
-  public void runInitByVar() {
-    try (Graph g = new Graph()) {
-      Ops tf = Ops.create(g);
-
-      Variable<TInt32> var1 = tf.variable(Shape.scalar(), TInt32.DTYPE);
-      tf.initAdd(tf.assign(var1, tf.constant(10)));
-      Variable<TInt32> var2 = tf.variable(tf.constant(20));
-      Add<TInt32> add = tf.math.add(var1, var2);
-      Init init = tf.withName("initialize").init();
-
-      try (Session s = new Session(g)) {
-        s.runInit(init);
+        s.run(tf.init());
 
         try (Tensor<TInt32> t = s.runner().fetch(add).run().get(0).expect(TInt32.DTYPE)) {
           assertEquals(30, t.data().getInt());
@@ -218,13 +195,13 @@ public void runInitByName() {
       tf.withName("init_test").init();
 
       try (Session s = new Session(g)) {
-        s.runInit("init_test");
+        s.run("init_test");
 
         try (Tensor<TInt32> t = s.runner().fetch(add).run().get(0).expect(TInt32.DTYPE)) {
           assertEquals(30, t.data().getInt());
         }
         try {
-          s.runInit("wrong_name");
+          s.run("wrong_name");
           fail();
         } catch (IllegalArgumentException e) {
           // as expected

From 8be3139d9138b7e484bf4e536ddee5f00dbb9fa9 Mon Sep 17 00:00:00 2001
From: Karl Lessard <karl.lessard@gmail.com>
Date: Thu, 2 Apr 2020 23:58:39 -0400
Subject: [PATCH 6/7] Remove traces

---
 .../org/tensorflow/processor/operator/OperatorProcessor.java | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/tensorflow-core/tensorflow-core-generator/src/main/java/org/tensorflow/processor/operator/OperatorProcessor.java b/tensorflow-core/tensorflow-core-generator/src/main/java/org/tensorflow/processor/operator/OperatorProcessor.java
index 1c750fbecce..d668c5e46d5 100644
--- a/tensorflow-core/tensorflow-core-generator/src/main/java/org/tensorflow/processor/operator/OperatorProcessor.java
+++ b/tensorflow-core/tensorflow-core-generator/src/main/java/org/tensorflow/processor/operator/OperatorProcessor.java
@@ -31,7 +31,6 @@
 import com.squareup.javapoet.TypeName;
 import com.squareup.javapoet.TypeSpec;
 import com.squareup.javapoet.TypeVariableName;
-import com.squareup.javapoet.WildcardTypeName;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -425,7 +424,7 @@ private static Collection<OpsSpec> collectGroupOps(OpsSpec ops, Multimap<String,
   }
 
   private static TypeSpec buildGroupClass(OpsSpec spec) {
-    System.out.println("Generating " + spec.className + " class");
+    //System.out.println("Generating " + spec.className + " class");
 
     MethodSpec.Builder ctorBuilder =
         MethodSpec.constructorBuilder()
@@ -454,7 +453,7 @@ private static TypeSpec buildGroupClass(OpsSpec spec) {
   }
 
   private static TypeSpec buildTopClass(OpsSpec spec) {
-    System.out.println("Generating " + spec.className + " class");
+    //System.out.println("Generating " + spec.className + " class");
 
     MethodSpec.Builder ctorBuilder =
         MethodSpec.constructorBuilder()

From 27e27f0ee77a8f38b0c0cbd70db98e7165311c90 Mon Sep 17 00:00:00 2001
From: Karl Lessard <karl.lessard@gmail.com>
Date: Fri, 3 Apr 2020 12:40:17 -0400
Subject: [PATCH 7/7] Update exception message

---
 .../src/main/java/org/tensorflow/Session.java                 | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Session.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Session.java
index fc80fe529ba..2e3e7387777 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Session.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Session.java
@@ -445,8 +445,8 @@ public Runner runner() {
   public void run(String opName) {
     Operation operation = graph.operation(opName);
     if (operation == null) {
-      throw new IllegalArgumentException("Initializer operation named '"
-          + opName + "' cannot be found in the graph");
+      throw new IllegalArgumentException("Operation named '" + opName
+          + "' cannot be found in the graph");
     }
     runner().addTarget(operation).run();
   }